Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 2c332a251302873cf8301c2aad27737b6df70255

Authored by Bodo Stroesser 2006-01-19 09:42:43 +0800

Committed by Linus Torvalds 2006-01-19 11:20:19 +0800

Exists in master and in 7 other branches

[PATCH] uml: change interface to boot_timer_handler

Current implementation of boot_timer_handler isn't usable for s390.  So I
changed its name to do_boot_timer_handler, taking (struct sigcontext *)sc as
argument.  do_boot_timer_handler is called from new boot_timer_handler() in
arch/um/os-Linux/signal.c, which uses the same mechanisms as other signal
handler to find out sigcontext pointer.

Signed-off-by: Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 2 changed files with 13 additions and 4 deletions Inline Diff

arch/um/kernel/time_kern.c
arch/um/os-Linux/signal.c

arch/um/kernel/time_kern.c

Diff comments View file @ 2c332a2

 /*
  * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
 #include "linux/kernel.h"
 #include "linux/module.h"
 #include "linux/unistd.h"
 #include "linux/stddef.h"
 #include "linux/spinlock.h"
 #include "linux/time.h"
 #include "linux/sched.h"
 #include "linux/interrupt.h"
 #include "linux/init.h"
 #include "linux/delay.h"
 #include "linux/hrtimer.h"
 #include "asm/irq.h"
 #include "asm/param.h"
 #include "asm/current.h"
 #include "kern_util.h"
 #include "user_util.h"
 #include "mode.h"
 #include "os.h"
 int hz(void)
 {
 	return(HZ);
 }
 /*
  * Scheduler clock - returns current time in nanosec units.
  */
 unsigned long long sched_clock(void)
 {
 	return (unsigned long long)jiffies_64 * (1000000000 / HZ);
 }
 /* Changed at early boot */
 int timer_irq_inited = 0;
 static int first_tick;
 static unsigned long long prev_nsecs;
 #ifdef CONFIG_UML_REAL_TIME_CLOCK
 static long long delta;   		/* Deviation per interval */
 #endif
 void timer_irq(union uml_pt_regs *regs)
 {
 	unsigned long long ticks = 0;
 	if(!timer_irq_inited){
 		/* This is to ensure that ticks don't pile up when
 		 * the timer handler is suspended */
 		first_tick = 0;
 		return;
 	}
 	if(first_tick){
 #ifdef CONFIG_UML_REAL_TIME_CLOCK
 		/* We've had 1 tick */
 		unsigned long long nsecs = os_nsecs();
 		delta += nsecs - prev_nsecs;
 		prev_nsecs = nsecs;
 		/* Protect against the host clock being set backwards */
 		if(delta < 0)
 			delta = 0;
 		ticks += (delta * HZ) / BILLION;
 		delta -= (ticks * BILLION) / HZ;
 #else
 		ticks = 1;
 #endif
 	}
 	else {
 		prev_nsecs = os_nsecs();
 		first_tick = 1;
 	}
 	while(ticks > 0){
 		do_IRQ(TIMER_IRQ, regs);
 		ticks--;
 	}
 }
-void boot_timer_handler(int sig)
+void do_boot_timer_handler(struct sigcontext * sc)
 {
 	struct pt_regs regs;
-	CHOOSE_MODE((void)
+	CHOOSE_MODE((void) (UPT_SC(&regs.regs) = sc),
-		    (UPT_SC(&regs.regs) = (struct sigcontext *) (&sig + 1)),
 		    (void) (regs.regs.skas.is_user = 0));
 	do_timer(&regs);
 }
 static DEFINE_SPINLOCK(timer_spinlock);
 static unsigned long long local_offset = 0;
 static inline unsigned long long get_time(void)
 {
 	unsigned long long nsecs;
 	unsigned long flags;
 	spin_lock_irqsave(&timer_spinlock, flags);
 	nsecs = os_nsecs();
 	nsecs += local_offset;
 	spin_unlock_irqrestore(&timer_spinlock, flags);
 	return nsecs;
 }
 irqreturn_t um_timer(int irq, void *dev, struct pt_regs *regs)
 {
 	unsigned long long nsecs;
 	unsigned long flags;
 	do_timer(regs);
 	write_seqlock_irqsave(&xtime_lock, flags);
 	nsecs = get_time() + local_offset;
 	xtime.tv_sec = nsecs / NSEC_PER_SEC;
 	xtime.tv_nsec = nsecs - xtime.tv_sec * NSEC_PER_SEC;
 	write_sequnlock_irqrestore(&xtime_lock, flags);
 	return(IRQ_HANDLED);
 }
 long um_time(int __user *tloc)
 {
 	long ret = get_time() / NSEC_PER_SEC;
 	if((tloc != NULL) && put_user(ret, tloc))
 		return -EFAULT;
 	return ret;
 }
 void do_gettimeofday(struct timeval *tv)
 {
 	unsigned long long nsecs = get_time();
 	tv->tv_sec = nsecs / NSEC_PER_SEC;
 	/* Careful about calculations here - this was originally done as
 	 * (nsecs - tv->tv_sec * NSEC_PER_SEC) / NSEC_PER_USEC
 	 * which gave bogus (> 1000000) values.  Dunno why, suspect gcc
 	 * (4.0.0) miscompiled it, or there's a subtle 64/32-bit conversion
 	 * problem that I missed.
 	 */
 	nsecs -= tv->tv_sec * NSEC_PER_SEC;
 	tv->tv_usec = (unsigned long) nsecs / NSEC_PER_USEC;
 }
 static inline void set_time(unsigned long long nsecs)
 {
 	unsigned long long now;
 	unsigned long flags;
 	spin_lock_irqsave(&timer_spinlock, flags);
 	now = os_nsecs();
 	local_offset = nsecs - now;
 	spin_unlock_irqrestore(&timer_spinlock, flags);
 	clock_was_set();
 }
 long um_stime(int __user *tptr)
 {
 	int value;
 	if (get_user(value, tptr))
                 return -EFAULT;
 	set_time((unsigned long long) value * NSEC_PER_SEC);
 	return 0;
 }
 int do_settimeofday(struct timespec *tv)
 {
 	set_time((unsigned long long) tv->tv_sec * NSEC_PER_SEC + tv->tv_nsec);
 	return 0;
 }
 void timer_handler(int sig, union uml_pt_regs *regs)
 {
 	local_irq_disable();
 	irq_enter();
 	update_process_times(CHOOSE_MODE(user_context(UPT_SP(regs)),
 					 (regs)->skas.is_user));
 	irq_exit();
 	local_irq_enable();
 	if(current_thread->cpu == 0)
 		timer_irq(regs);
 }
 int __init timer_init(void)
 {
 	int err;
 	user_time_init();
 	err = request_irq(TIMER_IRQ, um_timer, SA_INTERRUPT, "timer", NULL);
 	if(err != 0)
 		printk(KERN_ERR "timer_init : request_irq failed - "
 		       "errno = %d\n", -err);
 	timer_irq_inited = 1;
 	return(0);
 }
 __initcall(timer_init);

arch/um/os-Linux/signal.c

Diff comments View file @ 2c332a2

 /*
  * Copyright (C) 2004 PathScale, Inc
  * Licensed under the GPL
  */
 #include <signal.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <string.h>
 #include <sys/mman.h>
 #include "user_util.h"
-#include "kern_util.h"
 #include "user.h"
 #include "signal_kern.h"
 #include "sysdep/sigcontext.h"
 #include "sysdep/signal.h"
 #include "sigcontext.h"
 #include "mode.h"
 #include "os.h"
 void sig_handler(ARCH_SIGHDLR_PARAM)
 {
 	struct sigcontext *sc;
 	ARCH_GET_SIGCONTEXT(sc, sig);
 	CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
 			 sig, sc);
 }
 extern int timer_irq_inited;
 void alarm_handler(ARCH_SIGHDLR_PARAM)
 {
 	struct sigcontext *sc;
 	ARCH_GET_SIGCONTEXT(sc, sig);
 	if(!timer_irq_inited) return;
 	if(sig == SIGALRM)
 		switch_timers(0);
 	CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
 			 sig, sc);
 	if(sig == SIGALRM)
 		switch_timers(1);
+}
+extern void do_boot_timer_handler(struct sigcontext * sc);
+void boot_timer_handler(ARCH_SIGHDLR_PARAM)
+{
+	struct sigcontext *sc;
+	ARCH_GET_SIGCONTEXT(sc, sig);
+	do_boot_timer_handler(sc);
 }
 void set_sigstack(void *sig_stack, int size)
 {
 	stack_t stack = ((stack_t) { .ss_flags	= 0,
 				     .ss_sp	= (__ptr_t) sig_stack,
 				     .ss_size 	= size - sizeof(void *) });
 	if(sigaltstack(&stack, NULL) != 0)
 		panic("enabling signal stack failed, errno = %d\n", errno);
 }
 void remove_sigstack(void)
 {
 	stack_t stack = ((stack_t) { .ss_flags	= SS_DISABLE,
 				     .ss_sp	= NULL,
 				     .ss_size	= 0 });
 	if(sigaltstack(&stack, NULL) != 0)
 		panic("disabling signal stack failed, errno = %d\n", errno);
 }
 void set_handler(int sig, void (*handler)(int), int flags, ...)
 {
 	struct sigaction action;
 	va_list ap;
 	int mask;
 	va_start(ap, flags);
 	action.sa_handler = handler;
 	sigemptyset(&action.sa_mask);
 	while((mask = va_arg(ap, int)) != -1){
 		sigaddset(&action.sa_mask, mask);
 	}
 	va_end(ap);
 	action.sa_flags = flags;
 	action.sa_restorer = NULL;
 	if(sigaction(sig, &action, NULL) < 0)
 		panic("sigaction failed");
 }
 int change_sig(int signal, int on)
 {
 	sigset_t sigset, old;
 	sigemptyset(&sigset);
 	sigaddset(&sigset, signal);
 	sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, &old);
 	return(!sigismember(&old, signal));
 }
 /* Both here and in set/get_signal we don't touch SIGPROF, because we must not
  * disable profiling; it's safe because the profiling code does not interact
  * with the kernel code at all.*/
 static void change_signals(int type)
 {
 	sigset_t mask;
 	sigemptyset(&mask);
 	sigaddset(&mask, SIGVTALRM);
 	sigaddset(&mask, SIGALRM);
 	sigaddset(&mask, SIGIO);
 	if(sigprocmask(type, &mask, NULL) < 0)
 		panic("Failed to change signal mask - errno = %d", errno);
 }
 void block_signals(void)
 {
 	change_signals(SIG_BLOCK);
 }
 void unblock_signals(void)
 {
 	change_signals(SIG_UNBLOCK);
 }
 /* These are the asynchronous signals.  SIGVTALRM and SIGARLM are handled
  * together under SIGVTALRM_BIT.  SIGPROF is excluded because we want to
  * be able to profile all of UML, not just the non-critical sections.  If
  * profiling is not thread-safe, then that is not my problem.  We can disable
  * profiling when SMP is enabled in that case.
  */
 #define SIGIO_BIT 0
 #define SIGVTALRM_BIT 1
 static int enable_mask(sigset_t *mask)
 {
 	int sigs;
 	sigs = sigismember(mask, SIGIO) ? 0 : 1 << SIGIO_BIT;
 	sigs |= sigismember(mask, SIGVTALRM) ? 0 : 1 << SIGVTALRM_BIT;
 	sigs |= sigismember(mask, SIGALRM) ? 0 : 1 << SIGVTALRM_BIT;
 	return(sigs);
 }
 int get_signals(void)
 {
 	sigset_t mask;
 	if(sigprocmask(SIG_SETMASK, NULL, &mask) < 0)
 		panic("Failed to get signal mask");
 	return(enable_mask(&mask));
 }
 int set_signals(int enable)
 {
 	sigset_t mask;
 	int ret;
 	sigemptyset(&mask);
 	if(enable & (1 << SIGIO_BIT))
 		sigaddset(&mask, SIGIO);
 	if(enable & (1 << SIGVTALRM_BIT)){
 		sigaddset(&mask, SIGVTALRM);
 		sigaddset(&mask, SIGALRM);
 	}
 	/* This is safe - sigprocmask is guaranteed to copy locally the
 	 * value of new_set, do his work and then, at the end, write to
 	 * old_set.
 	 */
 	if(sigprocmask(SIG_UNBLOCK, &mask, &mask) < 0)
 		panic("Failed to enable signals");
 	ret = enable_mask(&mask);
 	sigemptyset(&mask);
 	if((enable & (1 << SIGIO_BIT)) == 0)
 		sigaddset(&mask, SIGIO);
 	if((enable & (1 << SIGVTALRM_BIT)) == 0){
 		sigaddset(&mask, SIGVTALRM);
 		sigaddset(&mask, SIGALRM);
 	}
 	if(sigprocmask(SIG_BLOCK, &mask, NULL) < 0)
 		panic("Failed to block signals");
 	return(ret);
 }