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