[mirror_ubuntu-bionic-kernel.git] / arch / s390 / kernel / vtime.c

/*
 *  arch/s390/kernel/vtime.c
 *    Virtual cpu timer based timer functions.
 *
 *  S390 version
 *    Copyright (C) 2004 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Jan Glauber <jan.glauber@de.ibm.com>
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/time.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/smp.h>
#include <linux/types.h>
#include <linux/timex.h>
#include <linux/notifier.h>
#include <linux/kernel_stat.h>
#include <linux/rcupdate.h>
#include <linux/posix-timers.h>

#include <asm/s390_ext.h>
#include <asm/timer.h>
#include <asm/irq_regs.h>
#include <asm/cpu.h>

static ext_int_info_t ext_int_info_timer;

static DEFINE_PER_CPU(struct vtimer_queue, virt_cpu_timer);

DEFINE_PER_CPU(struct s390_idle_data, s390_idle) = {
	.lock = __SPIN_LOCK_UNLOCKED(s390_idle.lock)
};

static inline __u64 get_vtimer(void)
{
	__u64 timer;

	asm volatile("STPT %0" : "=m" (timer));
	return timer;
}

static inline void set_vtimer(__u64 expires)
{
	__u64 timer;

	asm volatile ("  STPT %0\n"  /* Store current cpu timer value */
		      "  SPT %1"     /* Set new value immediatly afterwards */
		      : "=m" (timer) : "m" (expires) );
	S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
	S390_lowcore.last_update_timer = expires;
}

/*
 * Update process times based on virtual cpu times stored by entry.S
 * to the lowcore fields user_timer, system_timer & steal_clock.
 */
static void do_account_vtime(struct task_struct *tsk, int hardirq_offset)
{
	struct thread_info *ti = task_thread_info(tsk);
	__u64 timer, clock, user, system, steal;

	timer = S390_lowcore.last_update_timer;
	clock = S390_lowcore.last_update_clock;
	asm volatile ("  STPT %0\n"    /* Store current cpu timer value */
		      "  STCK %1"      /* Store current tod clock value */
		      : "=m" (S390_lowcore.last_update_timer),
		        "=m" (S390_lowcore.last_update_clock) );
	S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
	S390_lowcore.steal_timer += S390_lowcore.last_update_clock - clock;

	user = S390_lowcore.user_timer - ti->user_timer;
	S390_lowcore.steal_timer -= user;
	ti->user_timer = S390_lowcore.user_timer;
	account_user_time(tsk, user, user);

	system = S390_lowcore.system_timer - ti->system_timer;
	S390_lowcore.steal_timer -= system;
	ti->system_timer = S390_lowcore.system_timer;
	account_system_time(tsk, hardirq_offset, system, system);

	steal = S390_lowcore.steal_timer;
	if ((s64) steal > 0) {
		S390_lowcore.steal_timer = 0;
		account_steal_time(steal);
	}
}

void account_vtime(struct task_struct *prev, struct task_struct *next)
{
	struct thread_info *ti;

	do_account_vtime(prev, 0);
	ti = task_thread_info(prev);
	ti->user_timer = S390_lowcore.user_timer;
	ti->system_timer = S390_lowcore.system_timer;
	ti = task_thread_info(next);
	S390_lowcore.user_timer = ti->user_timer;
	S390_lowcore.system_timer = ti->system_timer;
}

void account_process_tick(struct task_struct *tsk, int user_tick)
{
	do_account_vtime(tsk, HARDIRQ_OFFSET);
}

/*
 * Update process times based on virtual cpu times stored by entry.S
 * to the lowcore fields user_timer, system_timer & steal_clock.
 */
void account_system_vtime(struct task_struct *tsk)
{
	struct thread_info *ti = task_thread_info(tsk);
	__u64 timer, system;

	timer = S390_lowcore.last_update_timer;
	S390_lowcore.last_update_timer = get_vtimer();
	S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;

	system = S390_lowcore.system_timer - ti->system_timer;
	S390_lowcore.steal_timer -= system;
	ti->system_timer = S390_lowcore.system_timer;
	account_system_time(tsk, 0, system, system);
}
EXPORT_SYMBOL_GPL(account_system_vtime);

void vtime_start_cpu(void)
{
	struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
	struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
	__u64 idle_time, expires;

	/* Account time spent with enabled wait psw loaded as idle time. */
	idle_time = S390_lowcore.int_clock - idle->idle_enter;
	account_idle_time(idle_time);
	S390_lowcore.steal_timer +=
		idle->idle_enter - S390_lowcore.last_update_clock;
	S390_lowcore.last_update_clock = S390_lowcore.int_clock;

	/* Account system time spent going idle. */
	S390_lowcore.system_timer += S390_lowcore.last_update_timer - vq->idle;
	S390_lowcore.last_update_timer = S390_lowcore.async_enter_timer;

	/* Restart vtime CPU timer */
	if (vq->do_spt) {
		/* Program old expire value but first save progress. */
		expires = vq->idle - S390_lowcore.async_enter_timer;
		expires += get_vtimer();
		set_vtimer(expires);
	} else {
		/* Don't account the CPU timer delta while the cpu was idle. */
		vq->elapsed -= vq->idle - S390_lowcore.async_enter_timer;
	}

	spin_lock(&idle->lock);
	idle->idle_time += idle_time;
	idle->idle_enter = 0ULL;
	idle->idle_count++;
	spin_unlock(&idle->lock);
}

void vtime_stop_cpu(void)
{
	struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
	struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
	psw_t psw;

	/* Wait for external, I/O or machine check interrupt. */
	psw.mask = psw_kernel_bits | PSW_MASK_WAIT | PSW_MASK_IO | PSW_MASK_EXT;

	/* Check if the CPU timer needs to be reprogrammed. */
	if (vq->do_spt) {
		__u64 vmax = VTIMER_MAX_SLICE;
		/*
		 * The inline assembly is equivalent to
		 *	vq->idle = get_cpu_timer();
		 *	set_cpu_timer(VTIMER_MAX_SLICE);
		 *	idle->idle_enter = get_clock();
		 *	__load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
		 *			   PSW_MASK_IO | PSW_MASK_EXT);
		 * The difference is that the inline assembly makes sure that
		 * the last three instruction are stpt, stck and lpsw in that
		 * order. This is done to increase the precision.
		 */
		asm volatile(
#ifndef CONFIG_64BIT
			"	basr	1,0\n"
			"0:	ahi	1,1f-0b\n"
			"	st	1,4(%2)\n"
#else /* CONFIG_64BIT */
			"	larl	1,1f\n"
			"	stg	1,8(%2)\n"
#endif /* CONFIG_64BIT */
			"	stpt	0(%4)\n"
			"	spt	0(%5)\n"
			"	stck	0(%3)\n"
#ifndef CONFIG_64BIT
			"	lpsw	0(%2)\n"
#else /* CONFIG_64BIT */
			"	lpswe	0(%2)\n"
#endif /* CONFIG_64BIT */
			"1:"
			: "=m" (idle->idle_enter), "=m" (vq->idle)
			: "a" (&psw), "a" (&idle->idle_enter),
			  "a" (&vq->idle), "a" (&vmax), "m" (vmax), "m" (psw)
			: "memory", "cc", "1");
	} else {
		/*
		 * The inline assembly is equivalent to
		 *	vq->idle = get_cpu_timer();
		 *	idle->idle_enter = get_clock();
		 *	__load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
		 *			   PSW_MASK_IO | PSW_MASK_EXT);
		 * The difference is that the inline assembly makes sure that
		 * the last three instruction are stpt, stck and lpsw in that
		 * order. This is done to increase the precision.
		 */
		asm volatile(
#ifndef CONFIG_64BIT
			"	basr	1,0\n"
			"0:	ahi	1,1f-0b\n"
			"	st	1,4(%2)\n"
#else /* CONFIG_64BIT */
			"	larl	1,1f\n"
			"	stg	1,8(%2)\n"
#endif /* CONFIG_64BIT */
			"	stpt	0(%4)\n"
			"	stck	0(%3)\n"
#ifndef CONFIG_64BIT
			"	lpsw	0(%2)\n"
#else /* CONFIG_64BIT */
			"	lpswe	0(%2)\n"
#endif /* CONFIG_64BIT */
			"1:"
			: "=m" (idle->idle_enter), "=m" (vq->idle)
			: "a" (&psw), "a" (&idle->idle_enter),
			  "a" (&vq->idle), "m" (psw)
			: "memory", "cc", "1");
	}
}

cputime64_t s390_get_idle_time(int cpu)
{
	struct s390_idle_data *idle;
	unsigned long long now, idle_time, idle_enter;

	idle = &per_cpu(s390_idle, cpu);
	spin_lock(&idle->lock);
	now = get_clock();
	idle_time = 0;
	idle_enter = idle->idle_enter;
	if (idle_enter != 0ULL && idle_enter < now)
		idle_time = now - idle_enter;
	spin_unlock(&idle->lock);
	return idle_time;
}

/*
 * Sorted add to a list. List is linear searched until first bigger
 * element is found.
 */
static void list_add_sorted(struct vtimer_list *timer, struct list_head *head)
{
	struct vtimer_list *event;

	list_for_each_entry(event, head, entry) {
		if (event->expires > timer->expires) {
			list_add_tail(&timer->entry, &event->entry);
			return;
		}
	}
	list_add_tail(&timer->entry, head);
}

/*
 * Do the callback functions of expired vtimer events.
 * Called from within the interrupt handler.
 */
static void do_callbacks(struct list_head *cb_list)
{
	struct vtimer_queue *vq;
	struct vtimer_list *event, *tmp;

	if (list_empty(cb_list))
		return;

	vq = &__get_cpu_var(virt_cpu_timer);

	list_for_each_entry_safe(event, tmp, cb_list, entry) {
		list_del_init(&event->entry);
		(event->function)(event->data);
		if (event->interval) {
			/* Recharge interval timer */
			event->expires = event->interval + vq->elapsed;
			spin_lock(&vq->lock);
			list_add_sorted(event, &vq->list);
			spin_unlock(&vq->lock);
		}
	}
}

/*
 * Handler for the virtual CPU timer.
 */
static void do_cpu_timer_interrupt(__u16 error_code)
{
	struct vtimer_queue *vq;
	struct vtimer_list *event, *tmp;
	struct list_head cb_list;	/* the callback queue */
	__u64 elapsed, next;

	INIT_LIST_HEAD(&cb_list);
	vq = &__get_cpu_var(virt_cpu_timer);

	/* walk timer list, fire all expired events */
	spin_lock(&vq->lock);

	elapsed = vq->elapsed + (vq->timer - S390_lowcore.async_enter_timer);
	BUG_ON((s64) elapsed < 0);
	vq->elapsed = 0;
	list_for_each_entry_safe(event, tmp, &vq->list, entry) {
		if (event->expires < elapsed)
			/* move expired timer to the callback queue */
			list_move_tail(&event->entry, &cb_list);
		else
			event->expires -= elapsed;
	}
	spin_unlock(&vq->lock);

	vq->do_spt = list_empty(&cb_list);
	do_callbacks(&cb_list);

	/* next event is first in list */
	next = VTIMER_MAX_SLICE;
	spin_lock(&vq->lock);
	if (!list_empty(&vq->list)) {
		event = list_first_entry(&vq->list, struct vtimer_list, entry);
		next = event->expires;
	} else
		vq->do_spt = 0;
	spin_unlock(&vq->lock);
	/*
	 * To improve precision add the time spent by the
	 * interrupt handler to the elapsed time.
	 * Note: CPU timer counts down and we got an interrupt,
	 *	 the current content is negative
	 */
	elapsed = S390_lowcore.async_enter_timer - get_vtimer();
	set_vtimer(next - elapsed);
	vq->timer = next - elapsed;
	vq->elapsed = elapsed;
}

void init_virt_timer(struct vtimer_list *timer)
{
	timer->function = NULL;
	INIT_LIST_HEAD(&timer->entry);
}
EXPORT_SYMBOL(init_virt_timer);

static inline int vtimer_pending(struct vtimer_list *timer)
{
	return (!list_empty(&timer->entry));
}

/*
 * this function should only run on the specified CPU
 */
static void internal_add_vtimer(struct vtimer_list *timer)
{
	struct vtimer_queue *vq;
	unsigned long flags;
	__u64 left, expires;

	vq = &per_cpu(virt_cpu_timer, timer->cpu);
	spin_lock_irqsave(&vq->lock, flags);

	BUG_ON(timer->cpu != smp_processor_id());

	if (list_empty(&vq->list)) {
		/* First timer on this cpu, just program it. */
		list_add(&timer->entry, &vq->list);
		set_vtimer(timer->expires);
		vq->timer = timer->expires;
		vq->elapsed = 0;
	} else {
		/* Check progress of old timers. */
		expires = timer->expires;
		left = get_vtimer();
		if (likely((s64) expires < (s64) left)) {
			/* The new timer expires before the current timer. */
			set_vtimer(expires);
			vq->elapsed += vq->timer - left;
			vq->timer = expires;
		} else {
			vq->elapsed += vq->timer - left;
			vq->timer = left;
		}
		/* Insert new timer into per cpu list. */
		timer->expires += vq->elapsed;
		list_add_sorted(timer, &vq->list);
	}

	spin_unlock_irqrestore(&vq->lock, flags);
	/* release CPU acquired in prepare_vtimer or mod_virt_timer() */
	put_cpu();
}

static inline void prepare_vtimer(struct vtimer_list *timer)
{
	BUG_ON(!timer->function);
	BUG_ON(!timer->expires || timer->expires > VTIMER_MAX_SLICE);
	BUG_ON(vtimer_pending(timer));
	timer->cpu = get_cpu();
}

/*
 * add_virt_timer - add an oneshot virtual CPU timer
 */
void add_virt_timer(void *new)
{
	struct vtimer_list *timer;

	timer = (struct vtimer_list *)new;
	prepare_vtimer(timer);
	timer->interval = 0;
	internal_add_vtimer(timer);
}
EXPORT_SYMBOL(add_virt_timer);

/*
 * add_virt_timer_int - add an interval virtual CPU timer
 */
void add_virt_timer_periodic(void *new)
{
	struct vtimer_list *timer;

	timer = (struct vtimer_list *)new;
	prepare_vtimer(timer);
	timer->interval = timer->expires;
	internal_add_vtimer(timer);
}
EXPORT_SYMBOL(add_virt_timer_periodic);

int __mod_vtimer(struct vtimer_list *timer, __u64 expires, int periodic)
{
	struct vtimer_queue *vq;
	unsigned long flags;
	int cpu;

	BUG_ON(!timer->function);
	BUG_ON(!expires || expires > VTIMER_MAX_SLICE);

	if (timer->expires == expires && vtimer_pending(timer))
		return 1;

	cpu = get_cpu();
	vq = &per_cpu(virt_cpu_timer, cpu);

	/* disable interrupts before test if timer is pending */
	spin_lock_irqsave(&vq->lock, flags);

	/* if timer isn't pending add it on the current CPU */
	if (!vtimer_pending(timer)) {
		spin_unlock_irqrestore(&vq->lock, flags);

		if (periodic)
			timer->interval = expires;
		else
			timer->interval = 0;
		timer->expires = expires;
		timer->cpu = cpu;
		internal_add_vtimer(timer);
		return 0;
	}

	/* check if we run on the right CPU */
	BUG_ON(timer->cpu != cpu);

	list_del_init(&timer->entry);
	timer->expires = expires;
	if (periodic)
		timer->interval = expires;

	/* the timer can't expire anymore so we can release the lock */
	spin_unlock_irqrestore(&vq->lock, flags);
	internal_add_vtimer(timer);
	return 1;
}

/*
 * If we change a pending timer the function must be called on the CPU
 * where the timer is running on.
 *
 * returns whether it has modified a pending timer (1) or not (0)
 */
int mod_virt_timer(struct vtimer_list *timer, __u64 expires)
{
	return __mod_vtimer(timer, expires, 0);
}
EXPORT_SYMBOL(mod_virt_timer);

/*
 * If we change a pending timer the function must be called on the CPU
 * where the timer is running on.
 *
 * returns whether it has modified a pending timer (1) or not (0)
 */
int mod_virt_timer_periodic(struct vtimer_list *timer, __u64 expires)
{
	return __mod_vtimer(timer, expires, 1);
}
EXPORT_SYMBOL(mod_virt_timer_periodic);

/*
 * delete a virtual timer
 *
 * returns whether the deleted timer was pending (1) or not (0)
 */
int del_virt_timer(struct vtimer_list *timer)
{
	unsigned long flags;
	struct vtimer_queue *vq;

	/* check if timer is pending */
	if (!vtimer_pending(timer))
		return 0;

	vq = &per_cpu(virt_cpu_timer, timer->cpu);
	spin_lock_irqsave(&vq->lock, flags);

	/* we don't interrupt a running timer, just let it expire! */
	list_del_init(&timer->entry);

	spin_unlock_irqrestore(&vq->lock, flags);
	return 1;
}
EXPORT_SYMBOL(del_virt_timer);

/*
 * Start the virtual CPU timer on the current CPU.
 */
void init_cpu_vtimer(void)
{
	struct vtimer_queue *vq;

	/* initialize per cpu vtimer structure */
	vq = &__get_cpu_var(virt_cpu_timer);
	INIT_LIST_HEAD(&vq->list);
	spin_lock_init(&vq->lock);

	/* enable cpu timer interrupts */
	__ctl_set_bit(0,10);
}

void __init vtime_init(void)
{
	/* request the cpu timer external interrupt */
	if (register_early_external_interrupt(0x1005, do_cpu_timer_interrupt,
					      &ext_int_info_timer) != 0)
		panic("Couldn't request external interrupt 0x1005");

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