Hi Thomas, I need to read it in detail - this is based on quickly scanning through it.
Based on my "experimental" notes, if you do not have a periodic timer setup in that part you have commented and marked as FIXME userspace at some point hangs (at least used to in 2.6.31 to 3.4, I have not tried later). If you have managed to fix it somewhere else, congrats. If 4.x does not do that any more - excellent too. I will read it properly on the plane (travelling) tomorrow and reply sometimes on Tue. A. On 03/05/15 16:46, Thomas Meyer wrote: > Am Samstag, den 02.05.2015, 12:08 +0100 schrieb Anton Ivanov: >> On 02/05/15 10:48, Thomas Meyer wrote: >>> Hi, >>> >>> I did port Anton's v4 patch to v4.1-rc1-56-g3d99e3f and run it the last >>> two days. >>> >>> Original v4 from Anton can be found here: >>> https://sourceforge.net/p/user-mode-linux/mailman/message/32856805/ >>> >>> Issues addressed in v5 version: >>> - Ported to v4.1-rc1-56-g3d99e3f >>> - Replaced IRQF_DISABLED with IRQF_TIMER in request_irq(). I'm not sure >>> if this is the right thing to do. >>> - Removed unused variable/function: bbev and sleep_time() >>> >>> What I don't understand is: >>> - why is SIGVTALRM/itimer is still used? wouldn't be enough to only use >>> the timer created by timer_create and SIGUSR2? >> Pacing userspace. There are a couple of places where it is hardwired so >> deeply into it that I was unable to remove it and replace it. For >> example there is one place where it is set-up using a magic number >> direct syscall incantation in the memory management subsystem and so on. >> >>> - why are still both IRQs are still registered in the uml kernel? >>> request_irq() for TIMER_IRQ and HRTIMER_IRQ? >> See above. >> >>> - doesn't occur duplicate signals now? One by SIGUSR2 and one from >>> SIGVTALRM? >> No >> >> VTALRM is still used for userpace pacing. All kernel stuff internally >> will use USR2. >> >> This results in: >> >> Userspace applications still having a relatively imprecise and expensive >> itimer based clock. All kernel stuff such as QoS, timeouts and timers in >> any kernel drivers, tcp timers will use the new high res timer. >> >> I would love to kill the old timer completely as this will make the >> userspace considerably more responsive, however some of the bits like >> the magic incantantions in the stub setups are beyond my understanding. > Hi, > > I've working on below patch based on your work, to completely kill the > itimer. It still has some error and things I don't understand yet, but > hopefully I'm heading in the right direction! > > Comments are welcome! > > diff --git a/arch/um/Makefile b/arch/um/Makefile > index 17d4460..a4a434f 100644 > --- a/arch/um/Makefile > +++ b/arch/um/Makefile > @@ -130,7 +130,7 @@ export LDS_ELF_FORMAT := $(ELF_FORMAT) > # The wrappers will select whether using "malloc" or the kernel allocator. > LINK_WRAPS = -Wl,--wrap,malloc -Wl,--wrap,free -Wl,--wrap,calloc > > -LD_FLAGS_CMDLINE = $(foreach opt,$(LDFLAGS),-Wl,$(opt)) > +LD_FLAGS_CMDLINE = $(foreach opt,$(LDFLAGS),-Wl,$(opt)) -lrt > > # Used by link-vmlinux.sh which has special support for um link > export CFLAGS_vmlinux := $(LINK-y) $(LINK_WRAPS) $(LD_FLAGS_CMDLINE) > diff --git a/arch/um/include/asm/irq.h b/arch/um/include/asm/irq.h > index 4a2037f..0f2a5b1 100644 > --- a/arch/um/include/asm/irq.h > +++ b/arch/um/include/asm/irq.h > @@ -16,8 +16,9 @@ > #define TELNETD_IRQ 12 > #define XTERM_IRQ 13 > #define RANDOM_IRQ 14 > +#define HRTIMER_IRQ 15 > > -#define LAST_IRQ RANDOM_IRQ > +#define LAST_IRQ HRTIMER_IRQ > #define NR_IRQS (LAST_IRQ + 1) > > #endif > diff --git a/arch/um/include/shared/as-layout.h > b/arch/um/include/shared/as-layout.h > index ca1843e..798aa6e 100644 > --- a/arch/um/include/shared/as-layout.h > +++ b/arch/um/include/shared/as-layout.h > @@ -17,7 +17,7 @@ > > /* Some constant macros are used in both assembler and > * C code. Therefore we cannot annotate them always with > - * 'UL' and other type specifiers unilaterally. We > + * 'UL' and other type specifiers unilaterally. We > * use the following macros to deal with this. > */ > > @@ -28,6 +28,13 @@ > #define _UML_AC(X, Y) __UML_AC(X, Y) > #endif > > +/** > + * userspace stub address space layout: > + * Below macros define the layout of the stub code and data > + * which are mapped in each userspace process: > + * - one page of code located at 0x100000 followed by > + * - one page of data > + */ > #define STUB_START _UML_AC(, 0x100000) > #define STUB_CODE _UML_AC((unsigned long), STUB_START) > #define STUB_DATA _UML_AC((unsigned long), STUB_CODE + UM_KERN_PAGE_SIZE) > diff --git a/arch/um/include/shared/kern_util.h > b/arch/um/include/shared/kern_util.h > index 83a91f9..0282b36 100644 > --- a/arch/um/include/shared/kern_util.h > +++ b/arch/um/include/shared/kern_util.h > @@ -37,6 +37,7 @@ extern void initial_thread_cb(void (*proc)(void *), void > *arg); > extern int is_syscall(unsigned long addr); > > extern void timer_handler(int sig, struct siginfo *unused_si, struct > uml_pt_regs *regs); > +extern void hrtimer_handler(int sig, struct siginfo *unused_si, struct > uml_pt_regs *regs); > > extern int start_uml(void); > extern void paging_init(void); > diff --git a/arch/um/include/shared/os.h b/arch/um/include/shared/os.h > index d824528..4eb382f 100644 > --- a/arch/um/include/shared/os.h > +++ b/arch/um/include/shared/os.h > @@ -217,7 +217,8 @@ extern int set_umid(char *name); > extern char *get_umid(void); > > /* signal.c */ > -extern void timer_init(void); > +extern void uml_timer_set_signal_handler(void); > +extern void uml_hrtimer_set_signal_handler(void); > extern void set_sigstack(void *sig_stack, int size); > extern void remove_sigstack(void); > extern void set_handler(int sig); > @@ -238,12 +239,16 @@ extern void um_early_printk(const char *s, unsigned int > n); > extern void os_fix_helper_signals(void); > > /* time.c */ > -extern void idle_sleep(unsigned long long nsecs); > -extern int set_interval(void); > -extern int timer_one_shot(int ticks); > -extern long long disable_timer(void); > +extern void os_idle_sleep(unsigned long long nsecs); > +extern int os_timer_create(void* timer); > +extern int os_timer_set_interval(void* timer); > +extern int os_timer_one_shot(int ticks); > +extern long long os_timer_disable(void); > +extern long os_timer_remain(void* timer); > extern void uml_idle_timer(void); > +extern long long os_persistent_clock_emulation(void); > extern long long os_nsecs(void); > +extern long long os_vnsecs(void); > > /* skas/mem.c */ > extern long run_syscall_stub(struct mm_id * mm_idp, > diff --git a/arch/um/include/shared/timer-internal.h > b/arch/um/include/shared/timer-internal.h > new file mode 100644 > index 0000000..afdc6dc > --- /dev/null > +++ b/arch/um/include/shared/timer-internal.h > @@ -0,0 +1,18 @@ > +/* > + * Copyright (C) 2012 - 2014 Cisco Systems > + * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) > + * Licensed under the GPL > + */ > + > +#ifndef __TIMER_INTERNAL_H__ > +#define __TIMER_INTERNAL_H__ > + > +#define TIMER_MULTIPLIER 256 > +#define TIMER_MIN_DELTA 500 > + > +extern void timer_lock(void); > +extern void timer_unlock(void); > + > +extern long long hrtimer_disable(void); > + > +#endif > diff --git a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c > index 23cb935..4c1966a 100644 > --- a/arch/um/kernel/irq.c > +++ b/arch/um/kernel/irq.c > @@ -338,20 +338,20 @@ static struct irq_chip normal_irq_type = { > .irq_unmask = dummy, > }; > > -static struct irq_chip SIGVTALRM_irq_type = { > - .name = "SIGVTALRM", > - .irq_disable = dummy, > - .irq_enable = dummy, > - .irq_ack = dummy, > - .irq_mask = dummy, > - .irq_unmask = dummy, > +static struct irq_chip SIGUSR2_irq_type = { > + .name = "SIGUSR2", > + .irq_disable = dummy, > + .irq_enable = dummy, > + .irq_ack = dummy, > + .irq_mask = dummy, > + .irq_unmask = dummy, > }; > > void __init init_IRQ(void) > { > int i; > > - irq_set_chip_and_handler(TIMER_IRQ, &SIGVTALRM_irq_type, > handle_edge_irq); > + irq_set_chip_and_handler(HRTIMER_IRQ, &SIGUSR2_irq_type, > handle_edge_irq); > > for (i = 1; i < NR_IRQS; i++) > irq_set_chip_and_handler(i, &normal_irq_type, handle_edge_irq); > diff --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c > index 68b9119..dab9c0b 100644 > --- a/arch/um/kernel/process.c > +++ b/arch/um/kernel/process.c > @@ -27,6 +27,7 @@ > #include <kern_util.h> > #include <os.h> > #include <skas.h> > +#include <timer-internal.h> > > /* > * This is a per-cpu array. A processor only modifies its entry and it only > @@ -204,8 +205,16 @@ void arch_cpu_idle(void) > unsigned long long nsecs; > > cpu_tasks[current_thread_info()->cpu].pid = os_getpid(); > - nsecs = disable_timer(); > - idle_sleep(nsecs); > + > + //WHAT? > + /* there is no benefit whatsoever in disabling a pending > + * hrtimer and setting a nanowait for the same value instead > + * so we do timer disable + wait only for the tracing one here > + */ > + > + nsecs = os_timer_disable(); > + os_idle_sleep(nsecs); > + os_timer_set_interval(NULL); > local_irq_enable(); > } > > diff --git a/arch/um/kernel/skas/clone.c b/arch/um/kernel/skas/clone.c > index 289771d..c1cdc2e 100644 > --- a/arch/um/kernel/skas/clone.c > +++ b/arch/um/kernel/skas/clone.c > @@ -35,10 +35,11 @@ stub_clone_handler(void) > if (err) > goto out; > > - err = stub_syscall3(__NR_setitimer, ITIMER_VIRTUAL, > - (long) &data->timer, 0); > - if (err) > - goto out; > +// WHY? FIXME: Switch to timer_create, timer_settime needed?! > +// err = stub_syscall3(__NR_setitimer, ITIMER_VIRTUAL, > +// (long) &data->timer, 0); > +// if (err) > +// goto out; > > remap_stack(data->fd, data->offset); > goto done; > diff --git a/arch/um/kernel/time.c b/arch/um/kernel/time.c > index 117568d..a568205 100644 > --- a/arch/um/kernel/time.c > +++ b/arch/um/kernel/time.c > @@ -1,4 +1,5 @@ > /* > + * Copyright (C) 2012-2014 Cisco Systems > * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) > * Licensed under the GPL > */ > @@ -8,32 +9,34 @@ > #include <linux/interrupt.h> > #include <linux/jiffies.h> > #include <linux/threads.h> > +#include <linux/spinlock.h> > #include <asm/irq.h> > #include <asm/param.h> > #include <kern_util.h> > #include <os.h> > +#include <timer-internal.h> > > -void timer_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs > *regs) > +void hrtimer_handler(int sig, struct siginfo *unused_si, struct uml_pt_regs > *regs) > { > unsigned long flags; > > local_irq_save(flags); > - do_IRQ(TIMER_IRQ, regs); > + do_IRQ(HRTIMER_IRQ, regs); > local_irq_restore(flags); > } > > -static void itimer_set_mode(enum clock_event_mode mode, > +static void timer_set_mode(enum clock_event_mode mode, > struct clock_event_device *evt) > { > switch (mode) { > case CLOCK_EVT_MODE_PERIODIC: > - set_interval(); > + os_timer_set_interval(NULL); > break; > > case CLOCK_EVT_MODE_SHUTDOWN: > case CLOCK_EVT_MODE_UNUSED: > case CLOCK_EVT_MODE_ONESHOT: > - disable_timer(); > + os_timer_disable(); > break; > > case CLOCK_EVT_MODE_RESUME: > @@ -41,68 +44,74 @@ static void itimer_set_mode(enum clock_event_mode mode, > } > } > > -static int itimer_next_event(unsigned long delta, > +static int timer_next_event(unsigned long delta, > struct clock_event_device *evt) > { > - return timer_one_shot(delta + 1); > + return os_timer_one_shot(delta); > } > > -static struct clock_event_device itimer_clockevent = { > - .name = "itimer", > +static struct clock_event_device timer_clockevent = { > + .name = "timer", > .rating = 250, > .cpumask = cpu_all_mask, > .features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT, > - .set_mode = itimer_set_mode, > - .set_next_event = itimer_next_event, > - .shift = 32, > + .set_mode = timer_set_mode, > + .set_next_event = timer_next_event, > + .shift = 0, > + .max_delta_ns = 0xffffffff, > + .min_delta_ns = TIMER_MIN_DELTA, //microsecond resolution should be > enough for anyone, same as 640K RAM > .irq = 0, > + .mult = 1, > }; > > -static irqreturn_t um_timer(int irq, void *dev) > +static irqreturn_t um_timer_irq(int irq, void *dev) > { > - (*itimer_clockevent.event_handler)(&itimer_clockevent); > + (*timer_clockevent.event_handler)(&timer_clockevent); > > return IRQ_HANDLED; > } > > -static cycle_t itimer_read(struct clocksource *cs) > +static cycle_t timer_read(struct clocksource *cs) > { > - return os_nsecs() / 1000; > + return os_nsecs() / TIMER_MULTIPLIER; > } > > -static struct clocksource itimer_clocksource = { > - .name = "itimer", > +static struct clocksource timer_clocksource = { > + .name = "timer", > .rating = 300, > - .read = itimer_read, > + .read = timer_read, > .mask = CLOCKSOURCE_MASK(64), > .flags = CLOCK_SOURCE_IS_CONTINUOUS, > }; > > -static void __init setup_itimer(void) > +static void __init timer_setup(void) > { > int err; > > - err = request_irq(TIMER_IRQ, um_timer, 0, "timer", NULL); > - if (err != 0) > + err = request_irq(HRTIMER_IRQ, um_timer_irq, IRQF_TIMER, "hr timer", > NULL); > + if (err != 0) { > printk(KERN_ERR "register_timer : request_irq failed - " > "errno = %d\n", -err); > + return; > + } > + > + err = os_timer_create(NULL); > + if (err != 0) { > + printk(KERN_ERR "creation of timer failed - errno = %d\n", -err); > + return; > + } > > - itimer_clockevent.mult = div_sc(HZ, NSEC_PER_SEC, 32); > - itimer_clockevent.max_delta_ns = > - clockevent_delta2ns(60 * HZ, &itimer_clockevent); > - itimer_clockevent.min_delta_ns = > - clockevent_delta2ns(1, &itimer_clockevent); > - err = clocksource_register_hz(&itimer_clocksource, USEC_PER_SEC); > + err = clocksource_register_hz(&timer_clocksource, > NSEC_PER_SEC/TIMER_MULTIPLIER); > if (err) { > printk(KERN_ERR "clocksource_register_hz returned %d\n", err); > return; > } > - clockevents_register_device(&itimer_clockevent); > + clockevents_register_device(&timer_clockevent); > } > > void read_persistent_clock(struct timespec *ts) > { > - long long nsecs = os_nsecs(); > + long long nsecs = os_persistent_clock_emulation(); > > set_normalized_timespec(ts, nsecs / NSEC_PER_SEC, > nsecs % NSEC_PER_SEC); > @@ -110,6 +119,6 @@ void read_persistent_clock(struct timespec *ts) > > void __init time_init(void) > { > - timer_init(); > - late_time_init = setup_itimer; > + uml_hrtimer_set_signal_handler(); > + late_time_init = timer_setup; > } > diff --git a/arch/um/os-Linux/internal.h b/arch/um/os-Linux/internal.h > deleted file mode 100644 > index 0dc2c9f..0000000 > --- a/arch/um/os-Linux/internal.h > +++ /dev/null > @@ -1 +0,0 @@ > -void alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc); > diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c > index df9191a..bd5907e 100644 > --- a/arch/um/os-Linux/main.c > +++ b/arch/um/os-Linux/main.c > @@ -168,8 +168,8 @@ int __init main(int argc, char **argv, char **envp) > * some time) and cause a segfault. > */ > > - /* stop timers and set SIGVTALRM to be ignored */ > - disable_timer(); > + /* stop timers and set timer signal to be ignored */ > + os_timer_disable(); > > /* disable SIGIO for the fds and set SIGIO to be ignored */ > err = deactivate_all_fds(); > diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c > index 7b605e4..ee6db2e 100644 > --- a/arch/um/os-Linux/signal.c > +++ b/arch/um/os-Linux/signal.c > @@ -13,7 +13,6 @@ > #include <kern_util.h> > #include <os.h> > #include <sysdep/mcontext.h> > -#include "internal.h" > > void (*sig_info[NSIG])(int, struct siginfo *, struct uml_pt_regs *) = { > [SIGTRAP] = relay_signal, > @@ -23,7 +22,8 @@ void (*sig_info[NSIG])(int, struct siginfo *, struct > uml_pt_regs *) = { > [SIGBUS] = bus_handler, > [SIGSEGV] = segv_handler, > [SIGIO] = sigio_handler, > - [SIGVTALRM] = timer_handler }; > + [SIGUSR2] = hrtimer_handler > +}; > > static void sig_handler_common(int sig, struct siginfo *si, mcontext_t *mc) > { > @@ -38,7 +38,7 @@ static void sig_handler_common(int sig, struct siginfo *si, > mcontext_t *mc) > } > > /* enable signals if sig isn't IRQ signal */ > - if ((sig != SIGIO) && (sig != SIGWINCH) && (sig != SIGVTALRM)) > + if ((sig != SIGIO) && (sig != SIGWINCH) && (sig != SIGVTALRM) && (sig > != SIGUSR2)) > unblock_signals(); > > (*sig_info[sig])(sig, si, &r); > @@ -55,8 +55,8 @@ static void sig_handler_common(int sig, struct siginfo *si, > mcontext_t *mc) > #define SIGIO_BIT 0 > #define SIGIO_MASK (1 << SIGIO_BIT) > > -#define SIGVTALRM_BIT 1 > -#define SIGVTALRM_MASK (1 << SIGVTALRM_BIT) > +#define SIGUSR2_BIT 2 > +#define SIGUSR2_MASK (1 << SIGUSR2_BIT) > > static int signals_enabled; > static unsigned int signals_pending; > @@ -78,46 +78,47 @@ void sig_handler(int sig, struct siginfo *si, mcontext_t > *mc) > set_signals(enabled); > } > > -static void real_alarm_handler(mcontext_t *mc) > +static void real_hralarm_handler(mcontext_t *mc) > { > struct uml_pt_regs regs; > > if (mc != NULL) > get_regs_from_mc(®s, mc); > regs.is_user = 0; > - unblock_signals(); > - timer_handler(SIGVTALRM, NULL, ®s); > + hrtimer_handler(SIGUSR2, NULL, ®s); > } > > -void alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc) > +void hralarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc) > { > int enabled; > > enabled = signals_enabled; > if (!signals_enabled) { > - signals_pending |= SIGVTALRM_MASK; > + signals_pending |= SIGUSR2_MASK; > return; > } > > block_signals(); > - > - real_alarm_handler(mc); > + real_hralarm_handler(mc); > set_signals(enabled); > } > > -void timer_init(void) > +void uml_hrtimer_set_signal_handler(void) > { > - set_handler(SIGVTALRM); > + set_handler(SIGUSR2); > } > > 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 *) }); > + stack_t stack = ((stack_t) { > + .ss_flags = 0, > + .ss_sp = (__ptr_t) sig_stack, > + .ss_size = size - sizeof(void *) > + }); > > - if (sigaltstack(&stack, NULL) != 0) > + if (sigaltstack(&stack, NULL) != 0) { > panic("enabling signal stack failed, errno = %d\n", errno); > + } > } > > static void (*handlers[_NSIG])(int sig, struct siginfo *si, mcontext_t *mc) > = { > @@ -129,10 +130,9 @@ static void (*handlers[_NSIG])(int sig, struct siginfo > *si, mcontext_t *mc) = { > > [SIGIO] = sig_handler, > [SIGWINCH] = sig_handler, > - [SIGVTALRM] = alarm_handler > + [SIGUSR2] = hralarm_handler > }; > > - > static void hard_handler(int sig, siginfo_t *si, void *p) > { > struct ucontext *uc = p; > @@ -176,6 +176,13 @@ static void hard_handler(int sig, siginfo_t *si, void *p) > } while (pending); > } > > +/** > + * set_handler() - enable signal in process' signal mask > + * @sig: The signal to enable > + * > + * Enable the given signal in the process' signal mask and > + * attach hard_handler() as handler routine > + */ > void set_handler(int sig) > { > struct sigaction action; > @@ -186,9 +193,9 @@ void set_handler(int sig) > > /* block irq ones */ > sigemptyset(&action.sa_mask); > - sigaddset(&action.sa_mask, SIGVTALRM); > sigaddset(&action.sa_mask, SIGIO); > sigaddset(&action.sa_mask, SIGWINCH); > + sigaddset(&action.sa_mask, SIGUSR2); > > if (sig == SIGSEGV) > flags |= SA_NODEFER; > @@ -281,8 +288,8 @@ void unblock_signals(void) > if (save_pending & SIGIO_MASK) > sig_handler_common(SIGIO, NULL, NULL); > > - if (save_pending & SIGVTALRM_MASK) > - real_alarm_handler(NULL); > + if (save_pending & SIGUSR2_MASK) > + real_hralarm_handler(NULL); > } > } > > @@ -298,9 +305,11 @@ int set_signals(int enable) > return enable; > > ret = signals_enabled; > - if (enable) > + if (enable) { > unblock_signals(); > - else block_signals(); > + } else { > + block_signals(); > + } > > return ret; > } > diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c > index 7a97775..555108a 100644 > --- a/arch/um/os-Linux/skas/process.c > +++ b/arch/um/os-Linux/skas/process.c > @@ -45,7 +45,7 @@ static int ptrace_dump_regs(int pid) > * Signals that are OK to receive in the stub - we'll just continue it. > * SIGWINCH will happen when UML is inside a detached screen. > */ > -#define STUB_SIG_MASK ((1 << SIGVTALRM) | (1 << SIGWINCH)) > +#define STUB_SIG_MASK ((1 << SIGVTALRM) | (1 << SIGWINCH) | (1 << SIGUSR2)) > > /* Signals that the stub will finish with - anything else is an error */ > #define STUB_DONE_MASK (1 << SIGTRAP) > @@ -176,17 +176,57 @@ static void handle_trap(int pid, struct uml_pt_regs > *regs, > > extern int __syscall_stub_start; > > +/** > + * userspace_tramp() - userspace trampoline > + * @stack: The address of the stack used for the new process (used for > + * SIGSEGV handling. > + * > + * The trampoline does execute as a new process after clone() > + * For each new userspace process the below code sets up > + * all necessary data: > + * 1.) enable ptrace from parent (the uml kernel) > + * 2.) Setup signal handling. Signals are inherited by the parent, i.e > + * the uml kernel > + * 3.) Create and start an posix (interval) timer for this process. > + * This timer will emulate the kernel timer ticks. > + * The timer signal will be processed by the kernel process in > userspace() > + * 4.) Map stub code page in the new process, i.e. the > + * userspace process: > + * The stub codes is used to catch syscalls from the userspace to > + * the kernel. > + * See linker scripts arch/um/kernel/dyn.lds.S (dynamic) resp. > + * arch/um/kernel/uml.lds.S (static) > + * for __syscall_stub_start defintion and > + * arch/um/kernel/skas/clone.c for the stub_handler itself. > + * 5.) Map stub data page in the new process, i.e. the > + * userspace process: > + * Setup an SIGSEGV handler into the new process. > + * Page faults will be catched and signaled to the kernel via this > + * mechanism. > + * See arch/x86/um/stub_segv.c for the handler itself. > + * 6.) Stop the new process and wait for the kernel to SIGCONT it agian > + * when it will get scheduled() > + */ > static int userspace_tramp(void *stack) > { > void *addr; > int err, fd; > unsigned long long offset; > + timer_t timer; > > ptrace(PTRACE_TRACEME, 0, 0, 0); > > signal(SIGTERM, SIG_DFL); > signal(SIGWINCH, SIG_IGN); > - err = set_interval(); > + > + err = os_timer_create(&timer); > + if (err) { > + printk(UM_KERN_ERR "userspace_tramp - creation of timer failed, > " > + "errno = %d\n", err); > + exit(1); > + } > + > + err = os_timer_set_interval(&timer); > if (err) { > printk(UM_KERN_ERR "userspace_tramp - setting timer failed, " > "errno = %d\n", err); > @@ -313,10 +353,16 @@ int start_userspace(unsigned long stub_stack) > return err; > } > > +/** > + * userspace() - user space control loop > + * @regs: ? > + * > + * The main loop that traces and controls each spwaned userspace > + * process, i.e. > + */ > void userspace(struct uml_pt_regs *regs) > { > - struct itimerval timer; > - unsigned long long nsecs, now; > + unsigned long long nsecs; > int err, status, op, pid = userspace_pid[0]; > /* To prevent races if using_sysemu changes under us.*/ > int local_using_sysemu; > @@ -325,13 +371,11 @@ void userspace(struct uml_pt_regs *regs) > /* Handle any immediate reschedules or signals */ > interrupt_end(); > > - if (getitimer(ITIMER_VIRTUAL, &timer)) > - printk(UM_KERN_ERR "Failed to get itimer, errno = %d\n", errno); > - nsecs = timer.it_value.tv_sec * UM_NSEC_PER_SEC + > - timer.it_value.tv_usec * UM_NSEC_PER_USEC; > - nsecs += os_nsecs(); > - > while (1) { > + > + nsecs = os_timer_remain(NULL); > + nsecs += os_nsecs(); > + > /* > * This can legitimately fail if the process loads a > * bogus value into a segment register. It will > @@ -388,31 +432,27 @@ void userspace(struct uml_pt_regs *regs) > switch (sig) { > case SIGSEGV: > if (PTRACE_FULL_FAULTINFO) { > - get_skas_faultinfo(pid, > - ®s->faultinfo); > - (*sig_info[SIGSEGV])(SIGSEGV, (struct > siginfo *)&si, > - regs); > + > get_skas_faultinfo(pid,®s->faultinfo); > + (*sig_info[SIGSEGV])(SIGSEGV, (struct > siginfo *)&si, regs); > + } else { > + handle_segv(pid, regs); > } > - else handle_segv(pid, regs); > break; > case SIGTRAP + 0x80: > - handle_trap(pid, regs, local_using_sysemu); > + handle_trap(pid, regs, local_using_sysemu); > break; > case SIGTRAP: > relay_signal(SIGTRAP, (struct siginfo *)&si, > regs); > break; > - case SIGVTALRM: > - now = os_nsecs(); > - if (now < nsecs) > + case SIGUSR2: > + /* only process the timer tick from userspace, > if the kernel > + * timer is not finished yet */ > + if (nsecs < os_nsecs()) { > break; > + } > block_signals(); > (*sig_info[sig])(sig, (struct siginfo *)&si, > regs); > unblock_signals(); > - nsecs = timer.it_value.tv_sec * > - UM_NSEC_PER_SEC + > - timer.it_value.tv_usec * > - UM_NSEC_PER_USEC; > - nsecs += os_nsecs(); > break; > case SIGIO: > case SIGILL: > @@ -448,8 +488,7 @@ static int __init init_thread_regs(void) > thread_regs[REGS_IP_INDEX] = STUB_CODE + > (unsigned long) stub_clone_handler - > (unsigned long) &__syscall_stub_start; > - thread_regs[REGS_SP_INDEX] = STUB_DATA + UM_KERN_PAGE_SIZE - > - sizeof(void *); > + thread_regs[REGS_SP_INDEX] = STUB_DATA + UM_KERN_PAGE_SIZE - > sizeof(void *); > #ifdef __SIGNAL_FRAMESIZE > thread_regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE; > #endif > @@ -460,23 +499,26 @@ __initcall(init_thread_regs); > > int copy_context_skas0(unsigned long new_stack, int pid) > { > - struct timeval tv = { .tv_sec = 0, .tv_usec = UM_USEC_PER_SEC / UM_HZ }; > + struct timeval tv = { .tv_sec = 0, .tv_usec = UM_NSEC_PER_SEC / UM_HZ }; > int err; > unsigned long current_stack = current_stub_stack(); > struct stub_data *data = (struct stub_data *) current_stack; > struct stub_data *child_data = (struct stub_data *) new_stack; > unsigned long long new_offset; > + > int new_fd = phys_mapping(to_phys((void *)new_stack), &new_offset); > > /* > * prepare offset and fd of child's stack as argument for parent's > * and child's mmap2 calls > */ > - *data = ((struct stub_data) { .offset = MMAP_OFFSET(new_offset), > - .fd = new_fd, > - .timer = ((struct itimerval) > - { .it_value = tv, > - .it_interval = tv }) }); > + *data = ((struct stub_data) { > + .offset = MMAP_OFFSET(new_offset), > + .fd = new_fd, > + .timer = ((struct itimerval) > + { .it_value = tv, > + .it_interval = tv }) > + }); > > err = ptrace_setregs(pid, thread_regs); > if (err < 0) { > diff --git a/arch/um/os-Linux/time.c b/arch/um/os-Linux/time.c > index e9824d5..d66d3b6 100644 > --- a/arch/um/os-Linux/time.c > +++ b/arch/um/os-Linux/time.c > @@ -1,4 +1,5 @@ > /* > + * Copyright (C) 2012-2014 Cisco Systems > * Copyright (C) 2000 - 2007 Jeff Dike (jdike{addtoit,linux.intel}.com) > * Licensed under the GPL > */ > @@ -10,73 +11,155 @@ > #include <sys/time.h> > #include <kern_util.h> > #include <os.h> > -#include "internal.h" > +#include <string.h> > +#include <timer-internal.h> > > -int set_interval(void) > +static timer_t event_high_res_timer = 0; > + > +static inline long long timeval_to_ns(const struct timeval *tv) > { > - int usec = UM_USEC_PER_SEC / UM_HZ; > - struct itimerval interval = ((struct itimerval) { { 0, usec }, > - { 0, usec } }); > + return ((long long) tv->tv_sec * UM_NSEC_PER_SEC) + > + tv->tv_usec * UM_NSEC_PER_USEC; > +} > > - if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) > - return -errno; > +static inline long long timespec_to_ns(const struct timespec *ts) > +{ > + return ((long long) ts->tv_sec * UM_NSEC_PER_SEC) + > + ts->tv_nsec; > +} > + > +long long os_persistent_clock_emulation (void) { > + struct timespec realtime_tp; > + > + clock_gettime(CLOCK_REALTIME, &realtime_tp); > + return timespec_to_ns(&realtime_tp); > +} > + > +/** > + * os_timer_create() - create an new posix (interval) timer > + */ > +int os_timer_create(void* timer) { > + > + struct sigevent sev; > + timer_t* t = timer; > > + if(t == NULL) { > + t = &event_high_res_timer; > + } > + > + sev.sigev_notify = SIGEV_SIGNAL; > + sev.sigev_signo = SIGUSR2; /* note - hrtimer now has its own signal */ > + sev.sigev_value.sival_ptr = &event_high_res_timer; > + > + if (timer_create( > + CLOCK_MONOTONIC, > + &sev, > + t) == -1) { > +// printk("Failed to create Timer"); > + return -1; > + } > +// printk("Event timer ID is 0x%lx\n", (long) *t); > return 0; > } > > -int timer_one_shot(int ticks) > +int os_timer_set_interval(void* timer) > { > - unsigned long usec = ticks * UM_USEC_PER_SEC / UM_HZ; > - unsigned long sec = usec / UM_USEC_PER_SEC; > - struct itimerval interval; > + struct itimerspec its; > + unsigned long long nsec; > + timer_t* t = timer; > + > + if(t == NULL) { > + t = &event_high_res_timer; > + } > > - usec %= UM_USEC_PER_SEC; > - interval = ((struct itimerval) { { 0, 0 }, { sec, usec } }); > + nsec = UM_NSEC_PER_SEC / UM_HZ; > > - if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) > + its.it_value.tv_sec = 0; > + its.it_value.tv_nsec = nsec; > + > + its.it_interval.tv_sec = 0; > + its.it_interval.tv_nsec = nsec; > + > + if(timer_settime(*t, 0, &its, NULL) == -1) { > return -errno; > + } > > return 0; > } > > /** > - * timeval_to_ns - Convert timeval to nanoseconds > - * @ts: pointer to the timeval variable to be converted > - * > - * Returns the scalar nanosecond representation of the timeval > - * parameter. > - * > - * Ripped from linux/time.h because it's a kernel header, and thus > - * unusable from here. > + * os_timer_remain() - returns the remaining nano seconds of the given > interval > + * timer > + * Because this is the remaining time of an interval timer, which > correspondends > + * to HZ, this value can never be bigger than one second. Just > + * the nanosecond part of the timer is returned. > + * The returned time is relative to the start time of the interval timer. > + * Return an negative value in an error case. > */ > -static inline long long timeval_to_ns(const struct timeval *tv) > +long os_timer_remain(void* timer) > { > - return ((long long) tv->tv_sec * UM_NSEC_PER_SEC) + > - tv->tv_usec * UM_NSEC_PER_USEC; > + struct itimerspec its; > + timer_t* t = timer; > + > + if(t == NULL) { > + t = &event_high_res_timer; > + } > + > + if(timer_gettime(t, &its) == -1) { > + return -errno; > + } > + > + return its.it_value.tv_nsec; > +} > + > +int os_timer_one_shot(int ticks) > +{ > + struct itimerspec its; > + unsigned long long nsec; > + unsigned long sec; > + > + nsec = (ticks + 1); > + sec = nsec / UM_NSEC_PER_SEC; > + nsec = nsec % UM_NSEC_PER_SEC; > + > + its.it_value.tv_sec = nsec / UM_NSEC_PER_SEC; > + its.it_value.tv_nsec = nsec; > + > + its.it_interval.tv_sec = 0; > + its.it_interval.tv_nsec = 0; // we cheat here > + > + timer_settime(event_high_res_timer, 0, &its, NULL); > + return 0; > } > > -long long disable_timer(void) > +/** > + * os_timer_disable() - disable the posix (interval) timer > + * Returns the remaining interval timer time in nanoseconds > + */ > +long long os_timer_disable(void) > { > - struct itimerval time = ((struct itimerval) { { 0, 0 }, { 0, 0 } }); > - long long remain, max = UM_NSEC_PER_SEC / UM_HZ; > + struct itimerspec its; > > - if (setitimer(ITIMER_VIRTUAL, &time, &time) < 0) > - printk(UM_KERN_ERR "disable_timer - setitimer failed, " > - "errno = %d\n", errno); > + memset(&its, 0, sizeof(struct itimerspec)); > + timer_settime(event_high_res_timer, 0, &its, &its); > + > + return its.it_value.tv_sec * UM_NSEC_PER_SEC + its.it_value.tv_nsec; > +} > > - remain = timeval_to_ns(&time.it_value); > - if (remain > max) > - remain = max; > +long long os_vnsecs(void) > +{ > + struct timespec ts; > > - return remain; > + clock_gettime(CLOCK_PROCESS_CPUTIME_ID,&ts); > + return timespec_to_ns(&ts); > } > > long long os_nsecs(void) > { > - struct timeval tv; > + struct timespec ts; > > - gettimeofday(&tv, NULL); > - return timeval_to_ns(&tv); > + clock_gettime(CLOCK_MONOTONIC,&ts); > + return timespec_to_ns(&ts); > } > > #ifdef UML_CONFIG_NO_HZ_COMMON > @@ -87,12 +170,7 @@ static int after_sleep_interval(struct timespec *ts) > > static void deliver_alarm(void) > { > - alarm_handler(SIGVTALRM, NULL, NULL); > -} > - > -static unsigned long long sleep_time(unsigned long long nsecs) > -{ > - return nsecs; > +// alarm_handler(SIGVTALRM, NULL, NULL); > } > > #else > @@ -102,14 +180,17 @@ unsigned long long skew; > static void deliver_alarm(void) > { > unsigned long long this_tick = os_nsecs(); > + //FIXME: int okay? > int one_tick = UM_NSEC_PER_SEC / UM_HZ; > > /* Protection against the host's time going backwards */ > - if ((last_tick != 0) && (this_tick < last_tick)) > + if ((last_tick != 0) && (this_tick < last_tick)) { > this_tick = last_tick; > + } > > - if (last_tick == 0) > + if (last_tick == 0) { > last_tick = this_tick - one_tick; > + } > > skew += this_tick - last_tick; > > @@ -132,7 +213,7 @@ static inline long long timespec_to_us(const struct > timespec *ts) > ts->tv_nsec / UM_NSEC_PER_USEC; > } > > -static int after_sleep_interval(struct timespec *ts) > +static int timer_after_sleep_interval(struct timespec *ts) > { > int usec = UM_USEC_PER_SEC / UM_HZ; > long long start_usecs = timespec_to_us(ts); > @@ -146,15 +227,16 @@ static int after_sleep_interval(struct timespec *ts) > * tick interval. If this happens, then just reduce the first > * tick to the interval value. > */ > - if (start_usecs > usec) > + if (start_usecs > usec) { > start_usecs = usec; > + } > > start_usecs -= skew / UM_NSEC_PER_USEC; > if (start_usecs < 0) > start_usecs = 0; > > tv = ((struct timeval) { .tv_sec = start_usecs / UM_USEC_PER_SEC, > - .tv_usec = start_usecs % UM_USEC_PER_SEC }); > + .tv_usec = start_usecs % UM_USEC_PER_SEC }); > interval = ((struct itimerval) { { 0, usec }, tv }); > > if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) > @@ -164,23 +246,33 @@ static int after_sleep_interval(struct timespec *ts) > } > #endif > > -void idle_sleep(unsigned long long nsecs) > +/** > + * os_idle_sleep() - sleep for a given time of nsecs > + * @nsecs: nanoseconds to sleep > + */ > +void os_idle_sleep(unsigned long long nsecs) > { > struct timespec ts; > > /* > - * nsecs can come in as zero, in which case, this starts a > - * busy loop. To prevent this, reset nsecs to the tick > - * interval if it is zero. > + * We sleep here for an interval that is not greater than HZ > + * We did not disable the timer in "disable" so if there is a timer > + * active it will wake us up right on time instead of doing > + * stupid things trying to program nanosleep in a race condition > + * manner. > */ > - if (nsecs == 0) > - nsecs = UM_NSEC_PER_SEC / UM_HZ; > > - nsecs = sleep_time(nsecs); > - ts = ((struct timespec) { .tv_sec = nsecs / UM_NSEC_PER_SEC, > - .tv_nsec = nsecs % UM_NSEC_PER_SEC }); > + if ((nsecs == 0) || (nsecs > UM_NSEC_PER_SEC / UM_HZ)) { > + nsecs = UM_NSEC_PER_SEC / UM_HZ ; > + } > > - if (nanosleep(&ts, &ts) == 0) > + ts = ((struct timespec) { > + .tv_sec = 0, > + .tv_nsec = nsecs > + }); > + > + if (clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, &ts) == 0) { > deliver_alarm(); > - after_sleep_interval(&ts); > + } > +// after_sleep_interval(&ts); > } > > > ------------------------------------------------------------------------------ One dashboard for servers and applications across Physical-Virtual-Cloud Widest out-of-the-box monitoring support with 50+ applications Performance metrics, stats and reports that give you Actionable Insights Deep dive visibility with transaction tracing using APM Insight. http://ad.doubleclick.net/ddm/clk/290420510;117567292;y _______________________________________________ User-mode-linux-devel mailing list User-mode-linux-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/user-mode-linux-devel
