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