arch/s390/kernel/vtime.c

   1 /*
   2  *    Virtual cpu timer based timer functions.
   3  *
   4  *    Copyright IBM Corp. 2004, 2012
   5  *    Author(s): Jan Glauber <jan.glauber@de.ibm.com>
   6  */
   7
   8 #include <linux/kernel_stat.h>
   9 #include <linux/notifier.h>
  10 #include <linux/kprobes.h>
  11 #include <linux/export.h>
  12 #include <linux/kernel.h>
  13 #include <linux/timex.h>
  14 #include <linux/types.h>
  15 #include <linux/time.h>
  16 #include <linux/cpu.h>
  17 #include <linux/smp.h>
  18
  19 #include <asm/irq_regs.h>
  20 #include <asm/cputime.h>
  21 #include <asm/vtimer.h>
  22 #include <asm/irq.h>
  23 #include "entry.h"
  24
  25 static void virt_timer_expire(void);
  26
  27 DEFINE_PER_CPU(struct s390_idle_data, s390_idle);
  28
  29 static LIST_HEAD(virt_timer_list);
  30 static DEFINE_SPINLOCK(virt_timer_lock);
  31 static atomic64_t virt_timer_current;
  32 static atomic64_t virt_timer_elapsed;
  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(
  47                 "       stpt    %0\n"   /* Store current cpu timer value */
  48                 "       spt     %1"     /* Set new value imm. afterwards */
  49                 : "=m" (timer) : "m" (expires));
  50         S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
  51         S390_lowcore.last_update_timer = expires;
  52 }
  53
  54 static inline int virt_timer_forward(u64 elapsed)
  55 {
  56         BUG_ON(!irqs_disabled());
  57
  58         if (list_empty(&virt_timer_list))
  59                 return 0;
  60         elapsed = atomic64_add_return(elapsed, &virt_timer_elapsed);
  61         return elapsed >= atomic64_read(&virt_timer_current);
  62 }
  63
  64 /*
  65  * Update process times based on virtual cpu times stored by entry.S
  66  * to the lowcore fields user_timer, system_timer & steal_clock.
  67  */
  68 static int do_account_vtime(struct task_struct *tsk, int hardirq_offset)
  69 {
  70         struct thread_info *ti = task_thread_info(tsk);
  71         u64 timer, clock, user, system, steal;
  72
  73         timer = S390_lowcore.last_update_timer;
  74         clock = S390_lowcore.last_update_clock;
  75         asm volatile(
  76                 "       stpt    %0\n"   /* Store current cpu timer value */
  77                 "       stck    %1"     /* Store current tod clock value */
  78                 : "=m" (S390_lowcore.last_update_timer),
  79                   "=m" (S390_lowcore.last_update_clock));
  80         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
  81         S390_lowcore.steal_timer += S390_lowcore.last_update_clock - clock;
  82
  83         user = S390_lowcore.user_timer - ti->user_timer;
  84         S390_lowcore.steal_timer -= user;
  85         ti->user_timer = S390_lowcore.user_timer;
  86         account_user_time(tsk, user, user);
  87
  88         system = S390_lowcore.system_timer - ti->system_timer;
  89         S390_lowcore.steal_timer -= system;
  90         ti->system_timer = S390_lowcore.system_timer;
  91         account_system_time(tsk, hardirq_offset, system, system);
  92
  93         steal = S390_lowcore.steal_timer;
  94         if ((s64) steal > 0) {
  95                 S390_lowcore.steal_timer = 0;
  96                 account_steal_time(steal);
  97         }
  98
  99         return virt_timer_forward(user + system);
 100 }
 101
 102 void vtime_task_switch(struct task_struct *prev)
 103 {
 104         struct thread_info *ti;
 105
 106         do_account_vtime(prev, 0);
 107         ti = task_thread_info(prev);
 108         ti->user_timer = S390_lowcore.user_timer;
 109         ti->system_timer = S390_lowcore.system_timer;
 110         ti = task_thread_info(current);
 111         S390_lowcore.user_timer = ti->user_timer;
 112         S390_lowcore.system_timer = ti->system_timer;
 113 }
 114
 115 void account_process_tick(struct task_struct *tsk, int user_tick)
 116 {
 117         if (do_account_vtime(tsk, HARDIRQ_OFFSET))
 118                 virt_timer_expire();
 119 }
 120
 121 /*
 122  * Update process times based on virtual cpu times stored by entry.S
 123  * to the lowcore fields user_timer, system_timer & steal_clock.
 124  */
 125 void vtime_account(struct task_struct *tsk)
 126 {
 127         struct thread_info *ti = task_thread_info(tsk);
 128         u64 timer, system;
 129
 130         timer = S390_lowcore.last_update_timer;
 131         S390_lowcore.last_update_timer = get_vtimer();
 132         S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
 133
 134         system = S390_lowcore.system_timer - ti->system_timer;
 135         S390_lowcore.steal_timer -= system;
 136         ti->system_timer = S390_lowcore.system_timer;
 137         account_system_time(tsk, 0, system, system);
 138
 139         virt_timer_forward(system);
 140 }
 141 EXPORT_SYMBOL_GPL(vtime_account);
 142
 143 void __vtime_account_system(struct task_struct *tsk)
 144 __attribute__((alias("vtime_account")));
 145 EXPORT_SYMBOL_GPL(__vtime_account_system);
 146
 147 void __kprobes vtime_stop_cpu(void)
 148 {
 149         struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
 150         unsigned long long idle_time;
 151         unsigned long psw_mask;
 152
 153         trace_hardirqs_on();
 154         /* Don't trace preempt off for idle. */
 155         stop_critical_timings();
 156
 157         /* Wait for external, I/O or machine check interrupt. */
 158         psw_mask = psw_kernel_bits | PSW_MASK_WAIT | PSW_MASK_DAT |
 159                 PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
 160         idle->nohz_delay = 0;
 161
 162         /* Call the assembler magic in entry.S */
 163         psw_idle(idle, psw_mask);
 164
 165         /* Reenable preemption tracer. */
 166         start_critical_timings();
 167
 168         /* Account time spent with enabled wait psw loaded as idle time. */
 169         idle->sequence++;
 170         smp_wmb();
 171         idle_time = idle->clock_idle_exit - idle->clock_idle_enter;
 172         idle->clock_idle_enter = idle->clock_idle_exit = 0ULL;
 173         idle->idle_time += idle_time;
 174         idle->idle_count++;
 175         account_idle_time(idle_time);
 176         smp_wmb();
 177         idle->sequence++;
 178 }
 179
 180 cputime64_t s390_get_idle_time(int cpu)
 181 {
 182         struct s390_idle_data *idle = &per_cpu(s390_idle, cpu);
 183         unsigned long long now, idle_enter, idle_exit;
 184         unsigned int sequence;
 185
 186         do {
 187                 now = get_clock();
 188                 sequence = ACCESS_ONCE(idle->sequence);
 189                 idle_enter = ACCESS_ONCE(idle->clock_idle_enter);
 190                 idle_exit = ACCESS_ONCE(idle->clock_idle_exit);
 191         } while ((sequence & 1) || (idle->sequence != sequence));
 192         return idle_enter ? ((idle_exit ?: now) - idle_enter) : 0;
 193 }
 194
 195 /*
 196  * Sorted add to a list. List is linear searched until first bigger
 197  * element is found.
 198  */
 199 static void list_add_sorted(struct vtimer_list *timer, struct list_head *head)
 200 {
 201         struct vtimer_list *tmp;
 202
 203         list_for_each_entry(tmp, head, entry) {
 204                 if (tmp->expires > timer->expires) {
 205                         list_add_tail(&timer->entry, &tmp->entry);
 206                         return;
 207                 }
 208         }
 209         list_add_tail(&timer->entry, head);
 210 }
 211
 212 /*
 213  * Handler for expired virtual CPU timer.
 214  */
 215 static void virt_timer_expire(void)
 216 {
 217         struct vtimer_list *timer, *tmp;
 218         unsigned long elapsed;
 219         LIST_HEAD(cb_list);
 220
 221         /* walk timer list, fire all expired timers */
 222         spin_lock(&virt_timer_lock);
 223         elapsed = atomic64_read(&virt_timer_elapsed);
 224         list_for_each_entry_safe(timer, tmp, &virt_timer_list, entry) {
 225                 if (timer->expires < elapsed)
 226                         /* move expired timer to the callback queue */
 227                         list_move_tail(&timer->entry, &cb_list);
 228                 else
 229                         timer->expires -= elapsed;
 230         }
 231         if (!list_empty(&virt_timer_list)) {
 232                 timer = list_first_entry(&virt_timer_list,
 233                                          struct vtimer_list, entry);
 234                 atomic64_set(&virt_timer_current, timer->expires);
 235         }
 236         atomic64_sub(elapsed, &virt_timer_elapsed);
 237         spin_unlock(&virt_timer_lock);
 238
 239         /* Do callbacks and recharge periodic timers */
 240         list_for_each_entry_safe(timer, tmp, &cb_list, entry) {
 241                 list_del_init(&timer->entry);
 242                 timer->function(timer->data);
 243                 if (timer->interval) {
 244                         /* Recharge interval timer */
 245                         timer->expires = timer->interval +
 246                                 atomic64_read(&virt_timer_elapsed);
 247                         spin_lock(&virt_timer_lock);
 248                         list_add_sorted(timer, &virt_timer_list);
 249                         spin_unlock(&virt_timer_lock);
 250                 }
 251         }
 252 }
 253
 254 void init_virt_timer(struct vtimer_list *timer)
 255 {
 256         timer->function = NULL;
 257         INIT_LIST_HEAD(&timer->entry);
 258 }
 259 EXPORT_SYMBOL(init_virt_timer);
 260
 261 static inline int vtimer_pending(struct vtimer_list *timer)
 262 {
 263         return !list_empty(&timer->entry);
 264 }
 265
 266 static void internal_add_vtimer(struct vtimer_list *timer)
 267 {
 268         if (list_empty(&virt_timer_list)) {
 269                 /* First timer, just program it. */
 270                 atomic64_set(&virt_timer_current, timer->expires);
 271                 atomic64_set(&virt_timer_elapsed, 0);
 272                 list_add(&timer->entry, &virt_timer_list);
 273         } else {
 274                 /* Update timer against current base. */
 275                 timer->expires += atomic64_read(&virt_timer_elapsed);
 276                 if (likely((s64) timer->expires <
 277                            (s64) atomic64_read(&virt_timer_current)))
 278                         /* The new timer expires before the current timer. */
 279                         atomic64_set(&virt_timer_current, timer->expires);
 280                 /* Insert new timer into the list. */
 281                 list_add_sorted(timer, &virt_timer_list);
 282         }
 283 }
 284
 285 static void __add_vtimer(struct vtimer_list *timer, int periodic)
 286 {
 287         unsigned long flags;
 288
 289         timer->interval = periodic ? timer->expires : 0;
 290         spin_lock_irqsave(&virt_timer_lock, flags);
 291         internal_add_vtimer(timer);
 292         spin_unlock_irqrestore(&virt_timer_lock, flags);
 293 }
 294
 295 /*
 296  * add_virt_timer - add an oneshot virtual CPU timer
 297  */
 298 void add_virt_timer(struct vtimer_list *timer)
 299 {
 300         __add_vtimer(timer, 0);
 301 }
 302 EXPORT_SYMBOL(add_virt_timer);
 303
 304 /*
 305  * add_virt_timer_int - add an interval virtual CPU timer
 306  */
 307 void add_virt_timer_periodic(struct vtimer_list *timer)
 308 {
 309         __add_vtimer(timer, 1);
 310 }
 311 EXPORT_SYMBOL(add_virt_timer_periodic);
 312
 313 static int __mod_vtimer(struct vtimer_list *timer, u64 expires, int periodic)
 314 {
 315         unsigned long flags;
 316         int rc;
 317
 318         BUG_ON(!timer->function);
 319
 320         if (timer->expires == expires && vtimer_pending(timer))
 321                 return 1;
 322         spin_lock_irqsave(&virt_timer_lock, flags);
 323         rc = vtimer_pending(timer);
 324         if (rc)
 325                 list_del_init(&timer->entry);
 326         timer->interval = periodic ? expires : 0;
 327         timer->expires = expires;
 328         internal_add_vtimer(timer);
 329         spin_unlock_irqrestore(&virt_timer_lock, flags);
 330         return rc;
 331 }
 332
 333 /*
 334  * returns whether it has modified a pending timer (1) or not (0)
 335  */
 336 int mod_virt_timer(struct vtimer_list *timer, u64 expires)
 337 {
 338         return __mod_vtimer(timer, expires, 0);
 339 }
 340 EXPORT_SYMBOL(mod_virt_timer);
 341
 342 /*
 343  * returns whether it has modified a pending timer (1) or not (0)
 344  */
 345 int mod_virt_timer_periodic(struct vtimer_list *timer, u64 expires)
 346 {
 347         return __mod_vtimer(timer, expires, 1);
 348 }
 349 EXPORT_SYMBOL(mod_virt_timer_periodic);
 350
 351 /*
 352  * Delete a virtual timer.
 353  *
 354  * returns whether the deleted timer was pending (1) or not (0)
 355  */
 356 int del_virt_timer(struct vtimer_list *timer)
 357 {
 358         unsigned long flags;
 359
 360         if (!vtimer_pending(timer))
 361                 return 0;
 362         spin_lock_irqsave(&virt_timer_lock, flags);
 363         list_del_init(&timer->entry);
 364         spin_unlock_irqrestore(&virt_timer_lock, flags);
 365         return 1;
 366 }
 367 EXPORT_SYMBOL(del_virt_timer);
 368
 369 /*
 370  * Start the virtual CPU timer on the current CPU.
 371  */
 372 void __cpuinit init_cpu_vtimer(void)
 373 {
 374         /* set initial cpu timer */
 375         set_vtimer(VTIMER_MAX_SLICE);
 376 }
 377
 378 static int __cpuinit s390_nohz_notify(struct notifier_block *self,
 379                                       unsigned long action, void *hcpu)
 380 {
 381         struct s390_idle_data *idle;
 382         long cpu = (long) hcpu;
 383
 384         idle = &per_cpu(s390_idle, cpu);
 385         switch (action & ~CPU_TASKS_FROZEN) {
 386         case CPU_DYING:
 387                 idle->nohz_delay = 0;
 388         default:
 389                 break;
 390         }
 391         return NOTIFY_OK;
 392 }
 393
 394 void __init vtime_init(void)
 395 {
 396         /* Enable cpu timer interrupts on the boot cpu. */
 397         init_cpu_vtimer();
 398         cpu_notifier(s390_nohz_notify, 0);
 399 }