Pull battery into release branch
[linux-2.6] / 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
23 #include <asm/s390_ext.h>
24 #include <asm/timer.h>
25 #include <asm/irq_regs.h>
26
27 static ext_int_info_t ext_int_info_timer;
28 static DEFINE_PER_CPU(struct vtimer_queue, virt_cpu_timer);
29
30 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
31 /*
32  * Update process times based on virtual cpu times stored by entry.S
33  * to the lowcore fields user_timer, system_timer & steal_clock.
34  */
35 void account_process_tick(struct task_struct *tsk, int user_tick)
36 {
37         cputime_t cputime;
38         __u64 timer, clock;
39         int rcu_user_flag;
40
41         timer = S390_lowcore.last_update_timer;
42         clock = S390_lowcore.last_update_clock;
43         asm volatile ("  STPT %0\n"    /* Store current cpu timer value */
44                       "  STCK %1"      /* Store current tod clock value */
45                       : "=m" (S390_lowcore.last_update_timer),
46                         "=m" (S390_lowcore.last_update_clock) );
47         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
48         S390_lowcore.steal_clock += S390_lowcore.last_update_clock - clock;
49
50         cputime = S390_lowcore.user_timer >> 12;
51         rcu_user_flag = cputime != 0;
52         S390_lowcore.user_timer -= cputime << 12;
53         S390_lowcore.steal_clock -= cputime << 12;
54         account_user_time(tsk, cputime);
55
56         cputime =  S390_lowcore.system_timer >> 12;
57         S390_lowcore.system_timer -= cputime << 12;
58         S390_lowcore.steal_clock -= cputime << 12;
59         account_system_time(tsk, HARDIRQ_OFFSET, cputime);
60
61         cputime = S390_lowcore.steal_clock;
62         if ((__s64) cputime > 0) {
63                 cputime >>= 12;
64                 S390_lowcore.steal_clock -= cputime << 12;
65                 account_steal_time(tsk, cputime);
66         }
67 }
68
69 /*
70  * Update process times based on virtual cpu times stored by entry.S
71  * to the lowcore fields user_timer, system_timer & steal_clock.
72  */
73 void account_vtime(struct task_struct *tsk)
74 {
75         cputime_t cputime;
76         __u64 timer;
77
78         timer = S390_lowcore.last_update_timer;
79         asm volatile ("  STPT %0"    /* Store current cpu timer value */
80                       : "=m" (S390_lowcore.last_update_timer) );
81         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
82
83         cputime = S390_lowcore.user_timer >> 12;
84         S390_lowcore.user_timer -= cputime << 12;
85         S390_lowcore.steal_clock -= cputime << 12;
86         account_user_time(tsk, cputime);
87
88         cputime =  S390_lowcore.system_timer >> 12;
89         S390_lowcore.system_timer -= cputime << 12;
90         S390_lowcore.steal_clock -= cputime << 12;
91         account_system_time(tsk, 0, cputime);
92 }
93
94 /*
95  * Update process times based on virtual cpu times stored by entry.S
96  * to the lowcore fields user_timer, system_timer & steal_clock.
97  */
98 void account_system_vtime(struct task_struct *tsk)
99 {
100         cputime_t cputime;
101         __u64 timer;
102
103         timer = S390_lowcore.last_update_timer;
104         asm volatile ("  STPT %0"    /* Store current cpu timer value */
105                       : "=m" (S390_lowcore.last_update_timer) );
106         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
107
108         cputime =  S390_lowcore.system_timer >> 12;
109         S390_lowcore.system_timer -= cputime << 12;
110         S390_lowcore.steal_clock -= cputime << 12;
111         account_system_time(tsk, 0, cputime);
112 }
113
114 static inline void set_vtimer(__u64 expires)
115 {
116         __u64 timer;
117
118         asm volatile ("  STPT %0\n"  /* Store current cpu timer value */
119                       "  SPT %1"     /* Set new value immediatly afterwards */
120                       : "=m" (timer) : "m" (expires) );
121         S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
122         S390_lowcore.last_update_timer = expires;
123
124         /* store expire time for this CPU timer */
125         __get_cpu_var(virt_cpu_timer).to_expire = expires;
126 }
127 #else
128 static inline void set_vtimer(__u64 expires)
129 {
130         S390_lowcore.last_update_timer = expires;
131         asm volatile ("SPT %0" : : "m" (S390_lowcore.last_update_timer));
132
133         /* store expire time for this CPU timer */
134         __get_cpu_var(virt_cpu_timer).to_expire = expires;
135 }
136 #endif
137
138 static void start_cpu_timer(void)
139 {
140         struct vtimer_queue *vt_list;
141
142         vt_list = &__get_cpu_var(virt_cpu_timer);
143
144         /* CPU timer interrupt is pending, don't reprogramm it */
145         if (vt_list->idle & 1LL<<63)
146                 return;
147
148         if (!list_empty(&vt_list->list))
149                 set_vtimer(vt_list->idle);
150 }
151
152 static void stop_cpu_timer(void)
153 {
154         struct vtimer_queue *vt_list;
155
156         vt_list = &__get_cpu_var(virt_cpu_timer);
157
158         /* nothing to do */
159         if (list_empty(&vt_list->list)) {
160                 vt_list->idle = VTIMER_MAX_SLICE;
161                 goto fire;
162         }
163
164         /* store the actual expire value */
165         asm volatile ("STPT %0" : "=m" (vt_list->idle));
166
167         /*
168          * If the CPU timer is negative we don't reprogramm
169          * it because we will get instantly an interrupt.
170          */
171         if (vt_list->idle & 1LL<<63)
172                 return;
173
174         vt_list->offset += vt_list->to_expire - vt_list->idle;
175
176         /*
177          * We cannot halt the CPU timer, we just write a value that
178          * nearly never expires (only after 71 years) and re-write
179          * the stored expire value if we continue the timer
180          */
181  fire:
182         set_vtimer(VTIMER_MAX_SLICE);
183 }
184
185 /*
186  * Sorted add to a list. List is linear searched until first bigger
187  * element is found.
188  */
189 static void list_add_sorted(struct vtimer_list *timer, struct list_head *head)
190 {
191         struct vtimer_list *event;
192
193         list_for_each_entry(event, head, entry) {
194                 if (event->expires > timer->expires) {
195                         list_add_tail(&timer->entry, &event->entry);
196                         return;
197                 }
198         }
199         list_add_tail(&timer->entry, head);
200 }
201
202 /*
203  * Do the callback functions of expired vtimer events.
204  * Called from within the interrupt handler.
205  */
206 static void do_callbacks(struct list_head *cb_list)
207 {
208         struct vtimer_queue *vt_list;
209         struct vtimer_list *event, *tmp;
210         void (*fn)(unsigned long);
211         unsigned long data;
212
213         if (list_empty(cb_list))
214                 return;
215
216         vt_list = &__get_cpu_var(virt_cpu_timer);
217
218         list_for_each_entry_safe(event, tmp, cb_list, entry) {
219                 fn = event->function;
220                 data = event->data;
221                 fn(data);
222
223                 if (!event->interval)
224                         /* delete one shot timer */
225                         list_del_init(&event->entry);
226                 else {
227                         /* move interval timer back to list */
228                         spin_lock(&vt_list->lock);
229                         list_del_init(&event->entry);
230                         list_add_sorted(event, &vt_list->list);
231                         spin_unlock(&vt_list->lock);
232                 }
233         }
234 }
235
236 /*
237  * Handler for the virtual CPU timer.
238  */
239 static void do_cpu_timer_interrupt(__u16 error_code)
240 {
241         __u64 next, delta;
242         struct vtimer_queue *vt_list;
243         struct vtimer_list *event, *tmp;
244         struct list_head *ptr;
245         /* the callback queue */
246         struct list_head cb_list;
247
248         INIT_LIST_HEAD(&cb_list);
249         vt_list = &__get_cpu_var(virt_cpu_timer);
250
251         /* walk timer list, fire all expired events */
252         spin_lock(&vt_list->lock);
253
254         if (vt_list->to_expire < VTIMER_MAX_SLICE)
255                 vt_list->offset += vt_list->to_expire;
256
257         list_for_each_entry_safe(event, tmp, &vt_list->list, entry) {
258                 if (event->expires > vt_list->offset)
259                         /* found first unexpired event, leave */
260                         break;
261
262                 /* re-charge interval timer, we have to add the offset */
263                 if (event->interval)
264                         event->expires = event->interval + vt_list->offset;
265
266                 /* move expired timer to the callback queue */
267                 list_move_tail(&event->entry, &cb_list);
268         }
269         spin_unlock(&vt_list->lock);
270         do_callbacks(&cb_list);
271
272         /* next event is first in list */
273         spin_lock(&vt_list->lock);
274         if (!list_empty(&vt_list->list)) {
275                 ptr = vt_list->list.next;
276                 event = list_entry(ptr, struct vtimer_list, entry);
277                 next = event->expires - vt_list->offset;
278
279                 /* add the expired time from this interrupt handler
280                  * and the callback functions
281                  */
282                 asm volatile ("STPT %0" : "=m" (delta));
283                 delta = 0xffffffffffffffffLL - delta + 1;
284                 vt_list->offset += delta;
285                 next -= delta;
286         } else {
287                 vt_list->offset = 0;
288                 next = VTIMER_MAX_SLICE;
289         }
290         spin_unlock(&vt_list->lock);
291         set_vtimer(next);
292 }
293
294 void init_virt_timer(struct vtimer_list *timer)
295 {
296         timer->function = NULL;
297         INIT_LIST_HEAD(&timer->entry);
298         spin_lock_init(&timer->lock);
299 }
300 EXPORT_SYMBOL(init_virt_timer);
301
302 static inline int vtimer_pending(struct vtimer_list *timer)
303 {
304         return (!list_empty(&timer->entry));
305 }
306
307 /*
308  * this function should only run on the specified CPU
309  */
310 static void internal_add_vtimer(struct vtimer_list *timer)
311 {
312         unsigned long flags;
313         __u64 done;
314         struct vtimer_list *event;
315         struct vtimer_queue *vt_list;
316
317         vt_list = &per_cpu(virt_cpu_timer, timer->cpu);
318         spin_lock_irqsave(&vt_list->lock, flags);
319
320         if (timer->cpu != smp_processor_id())
321                 printk("internal_add_vtimer: BUG, running on wrong CPU");
322
323         /* if list is empty we only have to set the timer */
324         if (list_empty(&vt_list->list)) {
325                 /* reset the offset, this may happen if the last timer was
326                  * just deleted by mod_virt_timer and the interrupt
327                  * didn't happen until here
328                  */
329                 vt_list->offset = 0;
330                 goto fire;
331         }
332
333         /* save progress */
334         asm volatile ("STPT %0" : "=m" (done));
335
336         /* calculate completed work */
337         done = vt_list->to_expire - done + vt_list->offset;
338         vt_list->offset = 0;
339
340         list_for_each_entry(event, &vt_list->list, entry)
341                 event->expires -= done;
342
343  fire:
344         list_add_sorted(timer, &vt_list->list);
345
346         /* get first element, which is the next vtimer slice */
347         event = list_entry(vt_list->list.next, struct vtimer_list, entry);
348
349         set_vtimer(event->expires);
350         spin_unlock_irqrestore(&vt_list->lock, flags);
351         /* release CPU acquired in prepare_vtimer or mod_virt_timer() */
352         put_cpu();
353 }
354
355 static inline int prepare_vtimer(struct vtimer_list *timer)
356 {
357         if (!timer->function) {
358                 printk("add_virt_timer: uninitialized timer\n");
359                 return -EINVAL;
360         }
361
362         if (!timer->expires || timer->expires > VTIMER_MAX_SLICE) {
363                 printk("add_virt_timer: invalid timer expire value!\n");
364                 return -EINVAL;
365         }
366
367         if (vtimer_pending(timer)) {
368                 printk("add_virt_timer: timer pending\n");
369                 return -EBUSY;
370         }
371
372         timer->cpu = get_cpu();
373         return 0;
374 }
375
376 /*
377  * add_virt_timer - add an oneshot virtual CPU timer
378  */
379 void add_virt_timer(void *new)
380 {
381         struct vtimer_list *timer;
382
383         timer = (struct vtimer_list *)new;
384
385         if (prepare_vtimer(timer) < 0)
386                 return;
387
388         timer->interval = 0;
389         internal_add_vtimer(timer);
390 }
391 EXPORT_SYMBOL(add_virt_timer);
392
393 /*
394  * add_virt_timer_int - add an interval virtual CPU timer
395  */
396 void add_virt_timer_periodic(void *new)
397 {
398         struct vtimer_list *timer;
399
400         timer = (struct vtimer_list *)new;
401
402         if (prepare_vtimer(timer) < 0)
403                 return;
404
405         timer->interval = timer->expires;
406         internal_add_vtimer(timer);
407 }
408 EXPORT_SYMBOL(add_virt_timer_periodic);
409
410 /*
411  * If we change a pending timer the function must be called on the CPU
412  * where the timer is running on, e.g. by smp_call_function_single()
413  *
414  * The original mod_timer adds the timer if it is not pending. For compatibility
415  * we do the same. The timer will be added on the current CPU as a oneshot timer.
416  *
417  * returns whether it has modified a pending timer (1) or not (0)
418  */
419 int mod_virt_timer(struct vtimer_list *timer, __u64 expires)
420 {
421         struct vtimer_queue *vt_list;
422         unsigned long flags;
423         int cpu;
424
425         if (!timer->function) {
426                 printk("mod_virt_timer: uninitialized timer\n");
427                 return  -EINVAL;
428         }
429
430         if (!expires || expires > VTIMER_MAX_SLICE) {
431                 printk("mod_virt_timer: invalid expire range\n");
432                 return -EINVAL;
433         }
434
435         /*
436          * This is a common optimization triggered by the
437          * networking code - if the timer is re-modified
438          * to be the same thing then just return:
439          */
440         if (timer->expires == expires && vtimer_pending(timer))
441                 return 1;
442
443         cpu = get_cpu();
444         vt_list = &per_cpu(virt_cpu_timer, cpu);
445
446         /* disable interrupts before test if timer is pending */
447         spin_lock_irqsave(&vt_list->lock, flags);
448
449         /* if timer isn't pending add it on the current CPU */
450         if (!vtimer_pending(timer)) {
451                 spin_unlock_irqrestore(&vt_list->lock, flags);
452                 /* we do not activate an interval timer with mod_virt_timer */
453                 timer->interval = 0;
454                 timer->expires = expires;
455                 timer->cpu = cpu;
456                 internal_add_vtimer(timer);
457                 return 0;
458         }
459
460         /* check if we run on the right CPU */
461         if (timer->cpu != cpu) {
462                 printk("mod_virt_timer: running on wrong CPU, check your code\n");
463                 spin_unlock_irqrestore(&vt_list->lock, flags);
464                 put_cpu();
465                 return -EINVAL;
466         }
467
468         list_del_init(&timer->entry);
469         timer->expires = expires;
470
471         /* also change the interval if we have an interval timer */
472         if (timer->interval)
473                 timer->interval = expires;
474
475         /* the timer can't expire anymore so we can release the lock */
476         spin_unlock_irqrestore(&vt_list->lock, flags);
477         internal_add_vtimer(timer);
478         return 1;
479 }
480 EXPORT_SYMBOL(mod_virt_timer);
481
482 /*
483  * delete a virtual timer
484  *
485  * returns whether the deleted timer was pending (1) or not (0)
486  */
487 int del_virt_timer(struct vtimer_list *timer)
488 {
489         unsigned long flags;
490         struct vtimer_queue *vt_list;
491
492         /* check if timer is pending */
493         if (!vtimer_pending(timer))
494                 return 0;
495
496         vt_list = &per_cpu(virt_cpu_timer, timer->cpu);
497         spin_lock_irqsave(&vt_list->lock, flags);
498
499         /* we don't interrupt a running timer, just let it expire! */
500         list_del_init(&timer->entry);
501
502         /* last timer removed */
503         if (list_empty(&vt_list->list)) {
504                 vt_list->to_expire = 0;
505                 vt_list->offset = 0;
506         }
507
508         spin_unlock_irqrestore(&vt_list->lock, flags);
509         return 1;
510 }
511 EXPORT_SYMBOL(del_virt_timer);
512
513 /*
514  * Start the virtual CPU timer on the current CPU.
515  */
516 void init_cpu_vtimer(void)
517 {
518         struct vtimer_queue *vt_list;
519
520         /* kick the virtual timer */
521         S390_lowcore.exit_timer = VTIMER_MAX_SLICE;
522         S390_lowcore.last_update_timer = VTIMER_MAX_SLICE;
523         asm volatile ("SPT %0" : : "m" (S390_lowcore.last_update_timer));
524         asm volatile ("STCK %0" : "=m" (S390_lowcore.last_update_clock));
525
526         /* enable cpu timer interrupts */
527         __ctl_set_bit(0,10);
528
529         vt_list = &__get_cpu_var(virt_cpu_timer);
530         INIT_LIST_HEAD(&vt_list->list);
531         spin_lock_init(&vt_list->lock);
532         vt_list->to_expire = 0;
533         vt_list->offset = 0;
534         vt_list->idle = 0;
535
536 }
537
538 static int vtimer_idle_notify(struct notifier_block *self,
539                               unsigned long action, void *hcpu)
540 {
541         switch (action) {
542         case S390_CPU_IDLE:
543                 stop_cpu_timer();
544                 break;
545         case S390_CPU_NOT_IDLE:
546                 start_cpu_timer();
547                 break;
548         }
549         return NOTIFY_OK;
550 }
551
552 static struct notifier_block vtimer_idle_nb = {
553         .notifier_call = vtimer_idle_notify,
554 };
555
556 void __init vtime_init(void)
557 {
558         /* request the cpu timer external interrupt */
559         if (register_early_external_interrupt(0x1005, do_cpu_timer_interrupt,
560                                               &ext_int_info_timer) != 0)
561                 panic("Couldn't request external interrupt 0x1005");
562
563         if (register_idle_notifier(&vtimer_idle_nb))
564                 panic("Couldn't register idle notifier");
565
566         /* Enable cpu timer interrupts on the boot cpu. */
567         init_cpu_vtimer();
568 }
569