7c6d861a1a407a0da03ff6bfb1d6097fef9791e0
[linux-3.10.git] / arch / s390 / kernel / vtime.c
1 /*
2  *    Virtual cpu timer based timer functions.
3  *
4  *    Copyright IBM Corp. 2004, 2012
5  *    Author(s): Jan Glauber <jan.glauber@de.ibm.com>
6  */
7
8 #include <linux/kernel_stat.h>
9 #include <linux/notifier.h>
10 #include <linux/kprobes.h>
11 #include <linux/export.h>
12 #include <linux/kernel.h>
13 #include <linux/timex.h>
14 #include <linux/types.h>
15 #include <linux/time.h>
16 #include <linux/cpu.h>
17 #include <linux/smp.h>
18
19 #include <asm/irq_regs.h>
20 #include <asm/cputime.h>
21 #include <asm/vtimer.h>
22 #include <asm/irq.h>
23 #include "entry.h"
24
25 static void virt_timer_expire(void);
26
27 DEFINE_PER_CPU(struct s390_idle_data, s390_idle);
28
29 static LIST_HEAD(virt_timer_list);
30 static DEFINE_SPINLOCK(virt_timer_lock);
31 static atomic64_t virt_timer_current;
32 static atomic64_t virt_timer_elapsed;
33
34 static inline u64 get_vtimer(void)
35 {
36         u64 timer;
37
38         asm volatile("stpt %0" : "=m" (timer));
39         return timer;
40 }
41
42 static inline void set_vtimer(u64 expires)
43 {
44         u64 timer;
45
46         asm volatile(
47                 "       stpt    %0\n"   /* Store current cpu timer value */
48                 "       spt     %1"     /* Set new value imm. afterwards */
49                 : "=m" (timer) : "m" (expires));
50         S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
51         S390_lowcore.last_update_timer = expires;
52 }
53
54 static inline int virt_timer_forward(u64 elapsed)
55 {
56         BUG_ON(!irqs_disabled());
57
58         if (list_empty(&virt_timer_list))
59                 return 0;
60         elapsed = atomic64_add_return(elapsed, &virt_timer_elapsed);
61         return elapsed >= atomic64_read(&virt_timer_current);
62 }
63
64 /*
65  * Update process times based on virtual cpu times stored by entry.S
66  * to the lowcore fields user_timer, system_timer & steal_clock.
67  */
68 static int do_account_vtime(struct task_struct *tsk, int hardirq_offset)
69 {
70         struct thread_info *ti = task_thread_info(tsk);
71         u64 timer, clock, user, system, steal;
72
73         timer = S390_lowcore.last_update_timer;
74         clock = S390_lowcore.last_update_clock;
75         asm volatile(
76                 "       stpt    %0\n"   /* Store current cpu timer value */
77                 "       stck    %1"     /* Store current tod clock value */
78                 : "=m" (S390_lowcore.last_update_timer),
79                   "=m" (S390_lowcore.last_update_clock));
80         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
81         S390_lowcore.steal_timer += S390_lowcore.last_update_clock - clock;
82
83         user = S390_lowcore.user_timer - ti->user_timer;
84         S390_lowcore.steal_timer -= user;
85         ti->user_timer = S390_lowcore.user_timer;
86         account_user_time(tsk, user, user);
87
88         system = S390_lowcore.system_timer - ti->system_timer;
89         S390_lowcore.steal_timer -= system;
90         ti->system_timer = S390_lowcore.system_timer;
91         account_system_time(tsk, hardirq_offset, system, system);
92
93         steal = S390_lowcore.steal_timer;
94         if ((s64) steal > 0) {
95                 S390_lowcore.steal_timer = 0;
96                 account_steal_time(steal);
97         }
98
99         return virt_timer_forward(user + system);
100 }
101
102 void vtime_task_switch(struct task_struct *prev)
103 {
104         struct thread_info *ti;
105
106         do_account_vtime(prev, 0);
107         ti = task_thread_info(prev);
108         ti->user_timer = S390_lowcore.user_timer;
109         ti->system_timer = S390_lowcore.system_timer;
110         ti = task_thread_info(current);
111         S390_lowcore.user_timer = ti->user_timer;
112         S390_lowcore.system_timer = ti->system_timer;
113 }
114
115 /*
116  * In s390, accounting pending user time also implies
117  * accounting system time in order to correctly compute
118  * the stolen time accounting.
119  */
120 void vtime_account_user(struct task_struct *tsk)
121 {
122         if (do_account_vtime(tsk, HARDIRQ_OFFSET))
123                 virt_timer_expire();
124 }
125
126 /*
127  * Update process times based on virtual cpu times stored by entry.S
128  * to the lowcore fields user_timer, system_timer & steal_clock.
129  */
130 void vtime_account(struct task_struct *tsk)
131 {
132         struct thread_info *ti = task_thread_info(tsk);
133         u64 timer, system;
134
135         timer = S390_lowcore.last_update_timer;
136         S390_lowcore.last_update_timer = get_vtimer();
137         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
138
139         system = S390_lowcore.system_timer - ti->system_timer;
140         S390_lowcore.steal_timer -= system;
141         ti->system_timer = S390_lowcore.system_timer;
142         account_system_time(tsk, 0, system, system);
143
144         virt_timer_forward(system);
145 }
146 EXPORT_SYMBOL_GPL(vtime_account);
147
148 void vtime_account_system(struct task_struct *tsk)
149 __attribute__((alias("vtime_account")));
150 EXPORT_SYMBOL_GPL(vtime_account_system);
151
152 void __kprobes vtime_stop_cpu(void)
153 {
154         struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
155         unsigned long long idle_time;
156         unsigned long psw_mask;
157
158         trace_hardirqs_on();
159         /* Don't trace preempt off for idle. */
160         stop_critical_timings();
161
162         /* Wait for external, I/O or machine check interrupt. */
163         psw_mask = psw_kernel_bits | PSW_MASK_WAIT | PSW_MASK_DAT |
164                 PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
165         idle->nohz_delay = 0;
166
167         /* Call the assembler magic in entry.S */
168         psw_idle(idle, psw_mask);
169
170         /* Reenable preemption tracer. */
171         start_critical_timings();
172
173         /* Account time spent with enabled wait psw loaded as idle time. */
174         idle->sequence++;
175         smp_wmb();
176         idle_time = idle->clock_idle_exit - idle->clock_idle_enter;
177         idle->clock_idle_enter = idle->clock_idle_exit = 0ULL;
178         idle->idle_time += idle_time;
179         idle->idle_count++;
180         account_idle_time(idle_time);
181         smp_wmb();
182         idle->sequence++;
183 }
184
185 cputime64_t s390_get_idle_time(int cpu)
186 {
187         struct s390_idle_data *idle = &per_cpu(s390_idle, cpu);
188         unsigned long long now, idle_enter, idle_exit;
189         unsigned int sequence;
190
191         do {
192                 now = get_clock();
193                 sequence = ACCESS_ONCE(idle->sequence);
194                 idle_enter = ACCESS_ONCE(idle->clock_idle_enter);
195                 idle_exit = ACCESS_ONCE(idle->clock_idle_exit);
196         } while ((sequence & 1) || (idle->sequence != sequence));
197         return idle_enter ? ((idle_exit ?: now) - idle_enter) : 0;
198 }
199
200 /*
201  * Sorted add to a list. List is linear searched until first bigger
202  * element is found.
203  */
204 static void list_add_sorted(struct vtimer_list *timer, struct list_head *head)
205 {
206         struct vtimer_list *tmp;
207
208         list_for_each_entry(tmp, head, entry) {
209                 if (tmp->expires > timer->expires) {
210                         list_add_tail(&timer->entry, &tmp->entry);
211                         return;
212                 }
213         }
214         list_add_tail(&timer->entry, head);
215 }
216
217 /*
218  * Handler for expired virtual CPU timer.
219  */
220 static void virt_timer_expire(void)
221 {
222         struct vtimer_list *timer, *tmp;
223         unsigned long elapsed;
224         LIST_HEAD(cb_list);
225
226         /* walk timer list, fire all expired timers */
227         spin_lock(&virt_timer_lock);
228         elapsed = atomic64_read(&virt_timer_elapsed);
229         list_for_each_entry_safe(timer, tmp, &virt_timer_list, entry) {
230                 if (timer->expires < elapsed)
231                         /* move expired timer to the callback queue */
232                         list_move_tail(&timer->entry, &cb_list);
233                 else
234                         timer->expires -= elapsed;
235         }
236         if (!list_empty(&virt_timer_list)) {
237                 timer = list_first_entry(&virt_timer_list,
238                                          struct vtimer_list, entry);
239                 atomic64_set(&virt_timer_current, timer->expires);
240         }
241         atomic64_sub(elapsed, &virt_timer_elapsed);
242         spin_unlock(&virt_timer_lock);
243
244         /* Do callbacks and recharge periodic timers */
245         list_for_each_entry_safe(timer, tmp, &cb_list, entry) {
246                 list_del_init(&timer->entry);
247                 timer->function(timer->data);
248                 if (timer->interval) {
249                         /* Recharge interval timer */
250                         timer->expires = timer->interval +
251                                 atomic64_read(&virt_timer_elapsed);
252                         spin_lock(&virt_timer_lock);
253                         list_add_sorted(timer, &virt_timer_list);
254                         spin_unlock(&virt_timer_lock);
255                 }
256         }
257 }
258
259 void init_virt_timer(struct vtimer_list *timer)
260 {
261         timer->function = NULL;
262         INIT_LIST_HEAD(&timer->entry);
263 }
264 EXPORT_SYMBOL(init_virt_timer);
265
266 static inline int vtimer_pending(struct vtimer_list *timer)
267 {
268         return !list_empty(&timer->entry);
269 }
270
271 static void internal_add_vtimer(struct vtimer_list *timer)
272 {
273         if (list_empty(&virt_timer_list)) {
274                 /* First timer, just program it. */
275                 atomic64_set(&virt_timer_current, timer->expires);
276                 atomic64_set(&virt_timer_elapsed, 0);
277                 list_add(&timer->entry, &virt_timer_list);
278         } else {
279                 /* Update timer against current base. */
280                 timer->expires += atomic64_read(&virt_timer_elapsed);
281                 if (likely((s64) timer->expires <
282                            (s64) atomic64_read(&virt_timer_current)))
283                         /* The new timer expires before the current timer. */
284                         atomic64_set(&virt_timer_current, timer->expires);
285                 /* Insert new timer into the list. */
286                 list_add_sorted(timer, &virt_timer_list);
287         }
288 }
289
290 static void __add_vtimer(struct vtimer_list *timer, int periodic)
291 {
292         unsigned long flags;
293
294         timer->interval = periodic ? timer->expires : 0;
295         spin_lock_irqsave(&virt_timer_lock, flags);
296         internal_add_vtimer(timer);
297         spin_unlock_irqrestore(&virt_timer_lock, flags);
298 }
299
300 /*
301  * add_virt_timer - add an oneshot virtual CPU timer
302  */
303 void add_virt_timer(struct vtimer_list *timer)
304 {
305         __add_vtimer(timer, 0);
306 }
307 EXPORT_SYMBOL(add_virt_timer);
308
309 /*
310  * add_virt_timer_int - add an interval virtual CPU timer
311  */
312 void add_virt_timer_periodic(struct vtimer_list *timer)
313 {
314         __add_vtimer(timer, 1);
315 }
316 EXPORT_SYMBOL(add_virt_timer_periodic);
317
318 static int __mod_vtimer(struct vtimer_list *timer, u64 expires, int periodic)
319 {
320         unsigned long flags;
321         int rc;
322
323         BUG_ON(!timer->function);
324
325         if (timer->expires == expires && vtimer_pending(timer))
326                 return 1;
327         spin_lock_irqsave(&virt_timer_lock, flags);
328         rc = vtimer_pending(timer);
329         if (rc)
330                 list_del_init(&timer->entry);
331         timer->interval = periodic ? expires : 0;
332         timer->expires = expires;
333         internal_add_vtimer(timer);
334         spin_unlock_irqrestore(&virt_timer_lock, flags);
335         return rc;
336 }
337
338 /*
339  * returns whether it has modified a pending timer (1) or not (0)
340  */
341 int mod_virt_timer(struct vtimer_list *timer, u64 expires)
342 {
343         return __mod_vtimer(timer, expires, 0);
344 }
345 EXPORT_SYMBOL(mod_virt_timer);
346
347 /*
348  * returns whether it has modified a pending timer (1) or not (0)
349  */
350 int mod_virt_timer_periodic(struct vtimer_list *timer, u64 expires)
351 {
352         return __mod_vtimer(timer, expires, 1);
353 }
354 EXPORT_SYMBOL(mod_virt_timer_periodic);
355
356 /*
357  * Delete a virtual timer.
358  *
359  * returns whether the deleted timer was pending (1) or not (0)
360  */
361 int del_virt_timer(struct vtimer_list *timer)
362 {
363         unsigned long flags;
364
365         if (!vtimer_pending(timer))
366                 return 0;
367         spin_lock_irqsave(&virt_timer_lock, flags);
368         list_del_init(&timer->entry);
369         spin_unlock_irqrestore(&virt_timer_lock, flags);
370         return 1;
371 }
372 EXPORT_SYMBOL(del_virt_timer);
373
374 /*
375  * Start the virtual CPU timer on the current CPU.
376  */
377 void __cpuinit init_cpu_vtimer(void)
378 {
379         /* set initial cpu timer */
380         set_vtimer(VTIMER_MAX_SLICE);
381 }
382
383 static int __cpuinit s390_nohz_notify(struct notifier_block *self,
384                                       unsigned long action, void *hcpu)
385 {
386         struct s390_idle_data *idle;
387         long cpu = (long) hcpu;
388
389         idle = &per_cpu(s390_idle, cpu);
390         switch (action & ~CPU_TASKS_FROZEN) {
391         case CPU_DYING:
392                 idle->nohz_delay = 0;
393         default:
394                 break;
395         }
396         return NOTIFY_OK;
397 }
398
399 void __init vtime_init(void)
400 {
401         /* Enable cpu timer interrupts on the boot cpu. */
402         init_cpu_vtimer();
403         cpu_notifier(s390_nohz_notify, 0);
404 }