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