bb48977f54697bdb1d68b34da3cc239947659ea2
[linux-2.6.git] / arch / s390 / kernel / vtime.c
1 /*
2  *  arch/s390/kernel/vtime.c
3  *    Virtual cpu timer based timer functions.
4  *
5  *  S390 version
6  *    Copyright (C) 2004 IBM Deutschland Entwicklung GmbH, IBM Corporation
7  *    Author(s): Jan Glauber <jan.glauber@de.ibm.com>
8  */
9
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/time.h>
13 #include <linux/delay.h>
14 #include <linux/init.h>
15 #include <linux/smp.h>
16 #include <linux/types.h>
17 #include <linux/timex.h>
18 #include <linux/notifier.h>
19 #include <linux/kernel_stat.h>
20 #include <linux/rcupdate.h>
21 #include <linux/posix-timers.h>
22 #include <linux/cpu.h>
23 #include <linux/kprobes.h>
24
25 #include <asm/timer.h>
26 #include <asm/irq_regs.h>
27 #include <asm/cputime.h>
28 #include <asm/irq.h>
29
30 static DEFINE_PER_CPU(struct vtimer_queue, virt_cpu_timer);
31
32 DEFINE_PER_CPU(struct s390_idle_data, s390_idle);
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 ("  STPT %0\n"  /* Store current cpu timer value */
47                       "  SPT %1"     /* Set new value immediately afterwards */
48                       : "=m" (timer) : "m" (expires) );
49         S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
50         S390_lowcore.last_update_timer = expires;
51 }
52
53 /*
54  * Update process times based on virtual cpu times stored by entry.S
55  * to the lowcore fields user_timer, system_timer & steal_clock.
56  */
57 static void do_account_vtime(struct task_struct *tsk, int hardirq_offset)
58 {
59         struct thread_info *ti = task_thread_info(tsk);
60         __u64 timer, clock, user, system, steal;
61
62         timer = S390_lowcore.last_update_timer;
63         clock = S390_lowcore.last_update_clock;
64         asm volatile ("  STPT %0\n"    /* Store current cpu timer value */
65                       "  STCK %1"      /* Store current tod clock value */
66                       : "=m" (S390_lowcore.last_update_timer),
67                         "=m" (S390_lowcore.last_update_clock) );
68         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
69         S390_lowcore.steal_timer += S390_lowcore.last_update_clock - clock;
70
71         user = S390_lowcore.user_timer - ti->user_timer;
72         S390_lowcore.steal_timer -= user;
73         ti->user_timer = S390_lowcore.user_timer;
74         account_user_time(tsk, user, user);
75
76         system = S390_lowcore.system_timer - ti->system_timer;
77         S390_lowcore.steal_timer -= system;
78         ti->system_timer = S390_lowcore.system_timer;
79         account_system_time(tsk, hardirq_offset, system, system);
80
81         steal = S390_lowcore.steal_timer;
82         if ((s64) steal > 0) {
83                 S390_lowcore.steal_timer = 0;
84                 account_steal_time(steal);
85         }
86 }
87
88 void account_vtime(struct task_struct *prev, struct task_struct *next)
89 {
90         struct thread_info *ti;
91
92         do_account_vtime(prev, 0);
93         ti = task_thread_info(prev);
94         ti->user_timer = S390_lowcore.user_timer;
95         ti->system_timer = S390_lowcore.system_timer;
96         ti = task_thread_info(next);
97         S390_lowcore.user_timer = ti->user_timer;
98         S390_lowcore.system_timer = ti->system_timer;
99 }
100
101 void account_process_tick(struct task_struct *tsk, int user_tick)
102 {
103         do_account_vtime(tsk, HARDIRQ_OFFSET);
104 }
105
106 /*
107  * Update process times based on virtual cpu times stored by entry.S
108  * to the lowcore fields user_timer, system_timer & steal_clock.
109  */
110 void account_system_vtime(struct task_struct *tsk)
111 {
112         struct thread_info *ti = task_thread_info(tsk);
113         __u64 timer, system;
114
115         timer = S390_lowcore.last_update_timer;
116         S390_lowcore.last_update_timer = get_vtimer();
117         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
118
119         system = S390_lowcore.system_timer - ti->system_timer;
120         S390_lowcore.steal_timer -= system;
121         ti->system_timer = S390_lowcore.system_timer;
122         account_system_time(tsk, 0, system, system);
123 }
124 EXPORT_SYMBOL_GPL(account_system_vtime);
125
126 void __kprobes vtime_start_cpu(__u64 int_clock, __u64 enter_timer)
127 {
128         struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
129         struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
130         __u64 idle_time, expires;
131
132         if (idle->idle_enter == 0ULL)
133                 return;
134
135         /* Account time spent with enabled wait psw loaded as idle time. */
136         idle_time = int_clock - idle->idle_enter;
137         account_idle_time(idle_time);
138         S390_lowcore.steal_timer +=
139                 idle->idle_enter - S390_lowcore.last_update_clock;
140         S390_lowcore.last_update_clock = int_clock;
141
142         /* Account system time spent going idle. */
143         S390_lowcore.system_timer += S390_lowcore.last_update_timer - vq->idle;
144         S390_lowcore.last_update_timer = enter_timer;
145
146         /* Restart vtime CPU timer */
147         if (vq->do_spt) {
148                 /* Program old expire value but first save progress. */
149                 expires = vq->idle - enter_timer;
150                 expires += get_vtimer();
151                 set_vtimer(expires);
152         } else {
153                 /* Don't account the CPU timer delta while the cpu was idle. */
154                 vq->elapsed -= vq->idle - enter_timer;
155         }
156
157         idle->sequence++;
158         smp_wmb();
159         idle->idle_time += idle_time;
160         idle->idle_enter = 0ULL;
161         idle->idle_count++;
162         smp_wmb();
163         idle->sequence++;
164 }
165
166 void __kprobes vtime_stop_cpu(void)
167 {
168         struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
169         struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
170         psw_t psw;
171
172         /* Wait for external, I/O or machine check interrupt. */
173         psw.mask = psw_kernel_bits | PSW_MASK_WAIT |
174                 PSW_MASK_DAT | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
175
176         idle->nohz_delay = 0;
177
178         /* Check if the CPU timer needs to be reprogrammed. */
179         if (vq->do_spt) {
180                 __u64 vmax = VTIMER_MAX_SLICE;
181                 /*
182                  * The inline assembly is equivalent to
183                  *      vq->idle = get_cpu_timer();
184                  *      set_cpu_timer(VTIMER_MAX_SLICE);
185                  *      idle->idle_enter = get_clock();
186                  *      __load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
187                  *                         PSW_MASK_DAT | PSW_MASK_IO |
188                  *                         PSW_MASK_EXT | PSW_MASK_MCHECK);
189                  * The difference is that the inline assembly makes sure that
190                  * the last three instruction are stpt, stck and lpsw in that
191                  * order. This is done to increase the precision.
192                  */
193                 asm volatile(
194 #ifndef CONFIG_64BIT
195                         "       basr    1,0\n"
196                         "0:     ahi     1,1f-0b\n"
197                         "       st      1,4(%2)\n"
198 #else /* CONFIG_64BIT */
199                         "       larl    1,1f\n"
200                         "       stg     1,8(%2)\n"
201 #endif /* CONFIG_64BIT */
202                         "       stpt    0(%4)\n"
203                         "       spt     0(%5)\n"
204                         "       stck    0(%3)\n"
205 #ifndef CONFIG_64BIT
206                         "       lpsw    0(%2)\n"
207 #else /* CONFIG_64BIT */
208                         "       lpswe   0(%2)\n"
209 #endif /* CONFIG_64BIT */
210                         "1:"
211                         : "=m" (idle->idle_enter), "=m" (vq->idle)
212                         : "a" (&psw), "a" (&idle->idle_enter),
213                           "a" (&vq->idle), "a" (&vmax), "m" (vmax), "m" (psw)
214                         : "memory", "cc", "1");
215         } else {
216                 /*
217                  * The inline assembly is equivalent to
218                  *      vq->idle = get_cpu_timer();
219                  *      idle->idle_enter = get_clock();
220                  *      __load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
221                  *                         PSW_MASK_DAT | PSW_MASK_IO |
222                  *                         PSW_MASK_EXT | PSW_MASK_MCHECK);
223                  * The difference is that the inline assembly makes sure that
224                  * the last three instruction are stpt, stck and lpsw in that
225                  * order. This is done to increase the precision.
226                  */
227                 asm volatile(
228 #ifndef CONFIG_64BIT
229                         "       basr    1,0\n"
230                         "0:     ahi     1,1f-0b\n"
231                         "       st      1,4(%2)\n"
232 #else /* CONFIG_64BIT */
233                         "       larl    1,1f\n"
234                         "       stg     1,8(%2)\n"
235 #endif /* CONFIG_64BIT */
236                         "       stpt    0(%4)\n"
237                         "       stck    0(%3)\n"
238 #ifndef CONFIG_64BIT
239                         "       lpsw    0(%2)\n"
240 #else /* CONFIG_64BIT */
241                         "       lpswe   0(%2)\n"
242 #endif /* CONFIG_64BIT */
243                         "1:"
244                         : "=m" (idle->idle_enter), "=m" (vq->idle)
245                         : "a" (&psw), "a" (&idle->idle_enter),
246                           "a" (&vq->idle), "m" (psw)
247                         : "memory", "cc", "1");
248         }
249 }
250
251 cputime64_t s390_get_idle_time(int cpu)
252 {
253         struct s390_idle_data *idle;
254         unsigned long long now, idle_time, idle_enter;
255         unsigned int sequence;
256
257         idle = &per_cpu(s390_idle, cpu);
258
259         now = get_clock();
260 repeat:
261         sequence = idle->sequence;
262         smp_rmb();
263         if (sequence & 1)
264                 goto repeat;
265         idle_time = 0;
266         idle_enter = idle->idle_enter;
267         if (idle_enter != 0ULL && idle_enter < now)
268                 idle_time = now - idle_enter;
269         smp_rmb();
270         if (idle->sequence != sequence)
271                 goto repeat;
272         return idle_time;
273 }
274
275 /*
276  * Sorted add to a list. List is linear searched until first bigger
277  * element is found.
278  */
279 static void list_add_sorted(struct vtimer_list *timer, struct list_head *head)
280 {
281         struct vtimer_list *event;
282
283         list_for_each_entry(event, head, entry) {
284                 if (event->expires > timer->expires) {
285                         list_add_tail(&timer->entry, &event->entry);
286                         return;
287                 }
288         }
289         list_add_tail(&timer->entry, head);
290 }
291
292 /*
293  * Do the callback functions of expired vtimer events.
294  * Called from within the interrupt handler.
295  */
296 static void do_callbacks(struct list_head *cb_list)
297 {
298         struct vtimer_queue *vq;
299         struct vtimer_list *event, *tmp;
300
301         if (list_empty(cb_list))
302                 return;
303
304         vq = &__get_cpu_var(virt_cpu_timer);
305
306         list_for_each_entry_safe(event, tmp, cb_list, entry) {
307                 list_del_init(&event->entry);
308                 (event->function)(event->data);
309                 if (event->interval) {
310                         /* Recharge interval timer */
311                         event->expires = event->interval + vq->elapsed;
312                         spin_lock(&vq->lock);
313                         list_add_sorted(event, &vq->list);
314                         spin_unlock(&vq->lock);
315                 }
316         }
317 }
318
319 /*
320  * Handler for the virtual CPU timer.
321  */
322 static void do_cpu_timer_interrupt(unsigned int ext_int_code,
323                                    unsigned int param32, unsigned long param64)
324 {
325         struct vtimer_queue *vq;
326         struct vtimer_list *event, *tmp;
327         struct list_head cb_list;       /* the callback queue */
328         __u64 elapsed, next;
329
330         kstat_cpu(smp_processor_id()).irqs[EXTINT_TMR]++;
331         INIT_LIST_HEAD(&cb_list);
332         vq = &__get_cpu_var(virt_cpu_timer);
333
334         /* walk timer list, fire all expired events */
335         spin_lock(&vq->lock);
336
337         elapsed = vq->elapsed + (vq->timer - S390_lowcore.async_enter_timer);
338         BUG_ON((s64) elapsed < 0);
339         vq->elapsed = 0;
340         list_for_each_entry_safe(event, tmp, &vq->list, entry) {
341                 if (event->expires < elapsed)
342                         /* move expired timer to the callback queue */
343                         list_move_tail(&event->entry, &cb_list);
344                 else
345                         event->expires -= elapsed;
346         }
347         spin_unlock(&vq->lock);
348
349         vq->do_spt = list_empty(&cb_list);
350         do_callbacks(&cb_list);
351
352         /* next event is first in list */
353         next = VTIMER_MAX_SLICE;
354         spin_lock(&vq->lock);
355         if (!list_empty(&vq->list)) {
356                 event = list_first_entry(&vq->list, struct vtimer_list, entry);
357                 next = event->expires;
358         } else
359                 vq->do_spt = 0;
360         spin_unlock(&vq->lock);
361         /*
362          * To improve precision add the time spent by the
363          * interrupt handler to the elapsed time.
364          * Note: CPU timer counts down and we got an interrupt,
365          *       the current content is negative
366          */
367         elapsed = S390_lowcore.async_enter_timer - get_vtimer();
368         set_vtimer(next - elapsed);
369         vq->timer = next - elapsed;
370         vq->elapsed = elapsed;
371 }
372
373 void init_virt_timer(struct vtimer_list *timer)
374 {
375         timer->function = NULL;
376         INIT_LIST_HEAD(&timer->entry);
377 }
378 EXPORT_SYMBOL(init_virt_timer);
379
380 static inline int vtimer_pending(struct vtimer_list *timer)
381 {
382         return (!list_empty(&timer->entry));
383 }
384
385 /*
386  * this function should only run on the specified CPU
387  */
388 static void internal_add_vtimer(struct vtimer_list *timer)
389 {
390         struct vtimer_queue *vq;
391         unsigned long flags;
392         __u64 left, expires;
393
394         vq = &per_cpu(virt_cpu_timer, timer->cpu);
395         spin_lock_irqsave(&vq->lock, flags);
396
397         BUG_ON(timer->cpu != smp_processor_id());
398
399         if (list_empty(&vq->list)) {
400                 /* First timer on this cpu, just program it. */
401                 list_add(&timer->entry, &vq->list);
402                 set_vtimer(timer->expires);
403                 vq->timer = timer->expires;
404                 vq->elapsed = 0;
405         } else {
406                 /* Check progress of old timers. */
407                 expires = timer->expires;
408                 left = get_vtimer();
409                 if (likely((s64) expires < (s64) left)) {
410                         /* The new timer expires before the current timer. */
411                         set_vtimer(expires);
412                         vq->elapsed += vq->timer - left;
413                         vq->timer = expires;
414                 } else {
415                         vq->elapsed += vq->timer - left;
416                         vq->timer = left;
417                 }
418                 /* Insert new timer into per cpu list. */
419                 timer->expires += vq->elapsed;
420                 list_add_sorted(timer, &vq->list);
421         }
422
423         spin_unlock_irqrestore(&vq->lock, flags);
424         /* release CPU acquired in prepare_vtimer or mod_virt_timer() */
425         put_cpu();
426 }
427
428 static inline void prepare_vtimer(struct vtimer_list *timer)
429 {
430         BUG_ON(!timer->function);
431         BUG_ON(!timer->expires || timer->expires > VTIMER_MAX_SLICE);
432         BUG_ON(vtimer_pending(timer));
433         timer->cpu = get_cpu();
434 }
435
436 /*
437  * add_virt_timer - add an oneshot virtual CPU timer
438  */
439 void add_virt_timer(void *new)
440 {
441         struct vtimer_list *timer;
442
443         timer = (struct vtimer_list *)new;
444         prepare_vtimer(timer);
445         timer->interval = 0;
446         internal_add_vtimer(timer);
447 }
448 EXPORT_SYMBOL(add_virt_timer);
449
450 /*
451  * add_virt_timer_int - add an interval virtual CPU timer
452  */
453 void add_virt_timer_periodic(void *new)
454 {
455         struct vtimer_list *timer;
456
457         timer = (struct vtimer_list *)new;
458         prepare_vtimer(timer);
459         timer->interval = timer->expires;
460         internal_add_vtimer(timer);
461 }
462 EXPORT_SYMBOL(add_virt_timer_periodic);
463
464 static int __mod_vtimer(struct vtimer_list *timer, __u64 expires, int periodic)
465 {
466         struct vtimer_queue *vq;
467         unsigned long flags;
468         int cpu;
469
470         BUG_ON(!timer->function);
471         BUG_ON(!expires || expires > VTIMER_MAX_SLICE);
472
473         if (timer->expires == expires && vtimer_pending(timer))
474                 return 1;
475
476         cpu = get_cpu();
477         vq = &per_cpu(virt_cpu_timer, cpu);
478
479         /* disable interrupts before test if timer is pending */
480         spin_lock_irqsave(&vq->lock, flags);
481
482         /* if timer isn't pending add it on the current CPU */
483         if (!vtimer_pending(timer)) {
484                 spin_unlock_irqrestore(&vq->lock, flags);
485
486                 if (periodic)
487                         timer->interval = expires;
488                 else
489                         timer->interval = 0;
490                 timer->expires = expires;
491                 timer->cpu = cpu;
492                 internal_add_vtimer(timer);
493                 return 0;
494         }
495
496         /* check if we run on the right CPU */
497         BUG_ON(timer->cpu != cpu);
498
499         list_del_init(&timer->entry);
500         timer->expires = expires;
501         if (periodic)
502                 timer->interval = expires;
503
504         /* the timer can't expire anymore so we can release the lock */
505         spin_unlock_irqrestore(&vq->lock, flags);
506         internal_add_vtimer(timer);
507         return 1;
508 }
509
510 /*
511  * If we change a pending timer the function must be called on the CPU
512  * where the timer is running on.
513  *
514  * returns whether it has modified a pending timer (1) or not (0)
515  */
516 int mod_virt_timer(struct vtimer_list *timer, __u64 expires)
517 {
518         return __mod_vtimer(timer, expires, 0);
519 }
520 EXPORT_SYMBOL(mod_virt_timer);
521
522 /*
523  * If we change a pending timer the function must be called on the CPU
524  * where the timer is running on.
525  *
526  * returns whether it has modified a pending timer (1) or not (0)
527  */
528 int mod_virt_timer_periodic(struct vtimer_list *timer, __u64 expires)
529 {
530         return __mod_vtimer(timer, expires, 1);
531 }
532 EXPORT_SYMBOL(mod_virt_timer_periodic);
533
534 /*
535  * delete a virtual timer
536  *
537  * returns whether the deleted timer was pending (1) or not (0)
538  */
539 int del_virt_timer(struct vtimer_list *timer)
540 {
541         unsigned long flags;
542         struct vtimer_queue *vq;
543
544         /* check if timer is pending */
545         if (!vtimer_pending(timer))
546                 return 0;
547
548         vq = &per_cpu(virt_cpu_timer, timer->cpu);
549         spin_lock_irqsave(&vq->lock, flags);
550
551         /* we don't interrupt a running timer, just let it expire! */
552         list_del_init(&timer->entry);
553
554         spin_unlock_irqrestore(&vq->lock, flags);
555         return 1;
556 }
557 EXPORT_SYMBOL(del_virt_timer);
558
559 /*
560  * Start the virtual CPU timer on the current CPU.
561  */
562 void init_cpu_vtimer(void)
563 {
564         struct vtimer_queue *vq;
565
566         /* initialize per cpu vtimer structure */
567         vq = &__get_cpu_var(virt_cpu_timer);
568         INIT_LIST_HEAD(&vq->list);
569         spin_lock_init(&vq->lock);
570
571         /* enable cpu timer interrupts */
572         __ctl_set_bit(0,10);
573 }
574
575 static int __cpuinit s390_nohz_notify(struct notifier_block *self,
576                                       unsigned long action, void *hcpu)
577 {
578         struct s390_idle_data *idle;
579         long cpu = (long) hcpu;
580
581         idle = &per_cpu(s390_idle, cpu);
582         switch (action) {
583         case CPU_DYING:
584         case CPU_DYING_FROZEN:
585                 idle->nohz_delay = 0;
586         default:
587                 break;
588         }
589         return NOTIFY_OK;
590 }
591
592 void __init vtime_init(void)
593 {
594         /* request the cpu timer external interrupt */
595         if (register_external_interrupt(0x1005, do_cpu_timer_interrupt))
596                 panic("Couldn't request external interrupt 0x1005");
597
598         /* Enable cpu timer interrupts on the boot cpu. */
599         init_cpu_vtimer();
600         cpu_notifier(s390_nohz_notify, 0);
601 }
602