umh: creds: convert call_usermodehelper_keys() to use subprocess_info->init()
[linux-2.6.git] / kernel / sched_clock.c
1 /*
2  * sched_clock for unstable cpu clocks
3  *
4  *  Copyright (C) 2008 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
5  *
6  *  Updates and enhancements:
7  *    Copyright (C) 2008 Red Hat, Inc. Steven Rostedt <srostedt@redhat.com>
8  *
9  * Based on code by:
10  *   Ingo Molnar <mingo@redhat.com>
11  *   Guillaume Chazarain <guichaz@gmail.com>
12  *
13  * Create a semi stable clock from a mixture of other events, including:
14  *  - gtod
15  *  - sched_clock()
16  *  - explicit idle events
17  *
18  * We use gtod as base and the unstable clock deltas. The deltas are filtered,
19  * making it monotonic and keeping it within an expected window.
20  *
21  * Furthermore, explicit sleep and wakeup hooks allow us to account for time
22  * that is otherwise invisible (TSC gets stopped).
23  *
24  * The clock: sched_clock_cpu() is monotonic per cpu, and should be somewhat
25  * consistent between cpus (never more than 2 jiffies difference).
26  */
27 #include <linux/spinlock.h>
28 #include <linux/hardirq.h>
29 #include <linux/module.h>
30 #include <linux/percpu.h>
31 #include <linux/ktime.h>
32 #include <linux/sched.h>
33
34 /*
35  * Scheduler clock - returns current time in nanosec units.
36  * This is default implementation.
37  * Architectures and sub-architectures can override this.
38  */
39 unsigned long long __attribute__((weak)) sched_clock(void)
40 {
41         return (unsigned long long)(jiffies - INITIAL_JIFFIES)
42                                         * (NSEC_PER_SEC / HZ);
43 }
44 EXPORT_SYMBOL_GPL(sched_clock);
45
46 static __read_mostly int sched_clock_running;
47
48 #ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
49 __read_mostly int sched_clock_stable;
50
51 struct sched_clock_data {
52         u64                     tick_raw;
53         u64                     tick_gtod;
54         u64                     clock;
55 };
56
57 static DEFINE_PER_CPU_SHARED_ALIGNED(struct sched_clock_data, sched_clock_data);
58
59 static inline struct sched_clock_data *this_scd(void)
60 {
61         return &__get_cpu_var(sched_clock_data);
62 }
63
64 static inline struct sched_clock_data *cpu_sdc(int cpu)
65 {
66         return &per_cpu(sched_clock_data, cpu);
67 }
68
69 void sched_clock_init(void)
70 {
71         u64 ktime_now = ktime_to_ns(ktime_get());
72         int cpu;
73
74         for_each_possible_cpu(cpu) {
75                 struct sched_clock_data *scd = cpu_sdc(cpu);
76
77                 scd->tick_raw = 0;
78                 scd->tick_gtod = ktime_now;
79                 scd->clock = ktime_now;
80         }
81
82         sched_clock_running = 1;
83 }
84
85 /*
86  * min, max except they take wrapping into account
87  */
88
89 static inline u64 wrap_min(u64 x, u64 y)
90 {
91         return (s64)(x - y) < 0 ? x : y;
92 }
93
94 static inline u64 wrap_max(u64 x, u64 y)
95 {
96         return (s64)(x - y) > 0 ? x : y;
97 }
98
99 /*
100  * update the percpu scd from the raw @now value
101  *
102  *  - filter out backward motion
103  *  - use the GTOD tick value to create a window to filter crazy TSC values
104  */
105 static u64 sched_clock_local(struct sched_clock_data *scd)
106 {
107         u64 now, clock, old_clock, min_clock, max_clock;
108         s64 delta;
109
110 again:
111         now = sched_clock();
112         delta = now - scd->tick_raw;
113         if (unlikely(delta < 0))
114                 delta = 0;
115
116         old_clock = scd->clock;
117
118         /*
119          * scd->clock = clamp(scd->tick_gtod + delta,
120          *                    max(scd->tick_gtod, scd->clock),
121          *                    scd->tick_gtod + TICK_NSEC);
122          */
123
124         clock = scd->tick_gtod + delta;
125         min_clock = wrap_max(scd->tick_gtod, old_clock);
126         max_clock = wrap_max(old_clock, scd->tick_gtod + TICK_NSEC);
127
128         clock = wrap_max(clock, min_clock);
129         clock = wrap_min(clock, max_clock);
130
131         if (cmpxchg64(&scd->clock, old_clock, clock) != old_clock)
132                 goto again;
133
134         return clock;
135 }
136
137 static u64 sched_clock_remote(struct sched_clock_data *scd)
138 {
139         struct sched_clock_data *my_scd = this_scd();
140         u64 this_clock, remote_clock;
141         u64 *ptr, old_val, val;
142
143         sched_clock_local(my_scd);
144 again:
145         this_clock = my_scd->clock;
146         remote_clock = scd->clock;
147
148         /*
149          * Use the opportunity that we have both locks
150          * taken to couple the two clocks: we take the
151          * larger time as the latest time for both
152          * runqueues. (this creates monotonic movement)
153          */
154         if (likely((s64)(remote_clock - this_clock) < 0)) {
155                 ptr = &scd->clock;
156                 old_val = remote_clock;
157                 val = this_clock;
158         } else {
159                 /*
160                  * Should be rare, but possible:
161                  */
162                 ptr = &my_scd->clock;
163                 old_val = this_clock;
164                 val = remote_clock;
165         }
166
167         if (cmpxchg64(ptr, old_val, val) != old_val)
168                 goto again;
169
170         return val;
171 }
172
173 u64 sched_clock_cpu(int cpu)
174 {
175         struct sched_clock_data *scd;
176         u64 clock;
177
178         WARN_ON_ONCE(!irqs_disabled());
179
180         if (sched_clock_stable)
181                 return sched_clock();
182
183         if (unlikely(!sched_clock_running))
184                 return 0ull;
185
186         scd = cpu_sdc(cpu);
187
188         if (cpu != smp_processor_id())
189                 clock = sched_clock_remote(scd);
190         else
191                 clock = sched_clock_local(scd);
192
193         return clock;
194 }
195
196 void sched_clock_tick(void)
197 {
198         struct sched_clock_data *scd;
199         u64 now, now_gtod;
200
201         if (sched_clock_stable)
202                 return;
203
204         if (unlikely(!sched_clock_running))
205                 return;
206
207         WARN_ON_ONCE(!irqs_disabled());
208
209         scd = this_scd();
210         now_gtod = ktime_to_ns(ktime_get());
211         now = sched_clock();
212
213         scd->tick_raw = now;
214         scd->tick_gtod = now_gtod;
215         sched_clock_local(scd);
216 }
217
218 /*
219  * We are going deep-idle (irqs are disabled):
220  */
221 void sched_clock_idle_sleep_event(void)
222 {
223         sched_clock_cpu(smp_processor_id());
224 }
225 EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event);
226
227 /*
228  * We just idled delta nanoseconds (called with irqs disabled):
229  */
230 void sched_clock_idle_wakeup_event(u64 delta_ns)
231 {
232         if (timekeeping_suspended)
233                 return;
234
235         sched_clock_tick();
236         touch_softlockup_watchdog();
237 }
238 EXPORT_SYMBOL_GPL(sched_clock_idle_wakeup_event);
239
240 unsigned long long cpu_clock(int cpu)
241 {
242         unsigned long long clock;
243         unsigned long flags;
244
245         local_irq_save(flags);
246         clock = sched_clock_cpu(cpu);
247         local_irq_restore(flags);
248
249         return clock;
250 }
251
252 #else /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
253
254 void sched_clock_init(void)
255 {
256         sched_clock_running = 1;
257 }
258
259 u64 sched_clock_cpu(int cpu)
260 {
261         if (unlikely(!sched_clock_running))
262                 return 0;
263
264         return sched_clock();
265 }
266
267
268 unsigned long long cpu_clock(int cpu)
269 {
270         return sched_clock_cpu(cpu);
271 }
272
273 #endif /* CONFIG_HAVE_UNSTABLE_SCHED_CLOCK */
274
275 EXPORT_SYMBOL_GPL(cpu_clock);