Subject: random: Make it work on rt From: Thomas Gleixner <tglx@linutronix.de> Date: Tue Aug 21 20:38:50 2012 +0200 From: Thomas Gleixner <tglx@linutronix.de> Delegate the random insertion to the forced threaded interrupt handler. Store the return IP of the hard interrupt handler in the irq descriptor and feed it into the random generator as a source of entropy. Signed-off-by: Thomas Gleixner <tglx@linutronix.de> --- arch/x86/kernel/cpu/mshyperv.c | 3 ++- drivers/char/random.c | 11 +++++------ drivers/hv/hyperv_vmbus.h | 1 + drivers/hv/vmbus_drv.c | 5 ++++- include/linux/irqdesc.h | 1 + include/linux/random.h | 2 +- kernel/irq/handle.c | 10 ++++++++-- kernel/irq/manage.c | 6 ++++++ 8 files changed, 28 insertions(+), 11 deletions(-) --- @ arch/x86/kernel/cpu/mshyperv.c:78 @ void hv_remove_vmbus_handler(void) DEFINE_IDTENTRY_SYSVEC(sysvec_hyperv_stimer0) { struct pt_regs *old_regs = set_irq_regs(regs); + u64 ip = regs ? instruction_pointer(regs) : 0; inc_irq_stat(hyperv_stimer0_count); if (hv_stimer0_handler) hv_stimer0_handler(); - add_interrupt_randomness(HYPERV_STIMER0_VECTOR, 0); + add_interrupt_randomness(HYPERV_STIMER0_VECTOR, 0, ip); ack_APIC_irq(); set_irq_regs(old_regs); --- a/drivers/char/random.c +++ b/drivers/char/random.c @ arch/x86/kernel/cpu/mshyperv.c:1245 @ static __u32 get_reg(struct fast_pool *f return *ptr; } -void add_interrupt_randomness(int irq, int irq_flags) +void add_interrupt_randomness(int irq, int irq_flags, __u64 ip) { struct entropy_store *r; struct fast_pool *fast_pool = this_cpu_ptr(&irq_randomness); - struct pt_regs *regs = get_irq_regs(); unsigned long now = jiffies; cycles_t cycles = random_get_entropy(); __u32 c_high, j_high; - __u64 ip; if (cycles == 0) - cycles = get_reg(fast_pool, regs); + cycles = get_reg(fast_pool, NULL); c_high = (sizeof(cycles) > 4) ? cycles >> 32 : 0; j_high = (sizeof(now) > 4) ? now >> 32 : 0; fast_pool->pool[0] ^= cycles ^ j_high ^ irq; fast_pool->pool[1] ^= now ^ c_high; - ip = regs ? instruction_pointer(regs) : _RET_IP_; + if (!ip) + ip = _RET_IP_; fast_pool->pool[2] ^= ip; fast_pool->pool[3] ^= (sizeof(ip) > 4) ? ip >> 32 : - get_reg(fast_pool, regs); + get_reg(fast_pool, NULL); fast_mix(fast_pool); add_interrupt_bench(cycles); --- a/drivers/hv/hyperv_vmbus.h +++ b/drivers/hv/hyperv_vmbus.h @ arch/x86/kernel/cpu/mshyperv.c:22 @ #include <linux/atomic.h> #include <linux/hyperv.h> #include <linux/interrupt.h> +#include <linux/irq.h> #include "hv_trace.h" --- a/drivers/hv/vmbus_drv.c +++ b/drivers/hv/vmbus_drv.c @ arch/x86/kernel/cpu/mshyperv.c:25 @ #include <linux/clockchips.h> #include <linux/cpu.h> #include <linux/sched/task_stack.h> +#include <linux/irq.h> #include <linux/delay.h> #include <linux/notifier.h> @ arch/x86/kernel/cpu/mshyperv.c:1341 @ static void vmbus_isr(void) void *page_addr = hv_cpu->synic_event_page; struct hv_message *msg; union hv_synic_event_flags *event; + struct pt_regs *regs = get_irq_regs(); + u64 ip = regs ? instruction_pointer(regs) : 0; bool handled = false; if (unlikely(page_addr == NULL)) @ arch/x86/kernel/cpu/mshyperv.c:1387 @ static void vmbus_isr(void) tasklet_schedule(&hv_cpu->msg_dpc); } - add_interrupt_randomness(vmbus_interrupt, 0); + add_interrupt_randomness(vmbus_interrupt, 0, ip); } static irqreturn_t vmbus_percpu_isr(int irq, void *dev_id) --- a/include/linux/irqdesc.h +++ b/include/linux/irqdesc.h @ arch/x86/kernel/cpu/mshyperv.c:71 @ struct irq_desc { unsigned int irqs_unhandled; atomic_t threads_handled; int threads_handled_last; + u64 random_ip; raw_spinlock_t lock; struct cpumask *percpu_enabled; const struct cpumask *percpu_affinity; --- a/include/linux/random.h +++ b/include/linux/random.h @ arch/x86/kernel/cpu/mshyperv.c:38 @ static inline void add_latent_entropy(vo extern void add_input_randomness(unsigned int type, unsigned int code, unsigned int value) __latent_entropy; -extern void add_interrupt_randomness(int irq, int irq_flags) __latent_entropy; +extern void add_interrupt_randomness(int irq, int irq_flags, __u64 ip) __latent_entropy; extern void get_random_bytes(void *buf, int nbytes); extern int wait_for_random_bytes(void); --- a/kernel/irq/handle.c +++ b/kernel/irq/handle.c @ arch/x86/kernel/cpu/mshyperv.c:193 @ irqreturn_t __handle_irq_event_percpu(st irqreturn_t handle_irq_event_percpu(struct irq_desc *desc) { - irqreturn_t retval; + struct pt_regs *regs = get_irq_regs(); + u64 ip = regs ? instruction_pointer(regs) : 0; unsigned int flags = 0; + irqreturn_t retval; retval = __handle_irq_event_percpu(desc, &flags); - add_interrupt_randomness(desc->irq_data.irq, flags); +#ifdef CONFIG_PREEMPT_RT + desc->random_ip = ip; +#else + add_interrupt_randomness(desc->irq_data.irq, flags, ip); +#endif if (!irq_settings_no_debug(desc)) note_interrupt(desc, retval); --- a/kernel/irq/manage.c +++ b/kernel/irq/manage.c @ arch/x86/kernel/cpu/mshyperv.c:1284 @ static int irq_thread(void *data) if (action_ret == IRQ_WAKE_THREAD) irq_wake_secondary(desc, action); + if (IS_ENABLED(CONFIG_PREEMPT_RT)) { + migrate_disable(); + add_interrupt_randomness(action->irq, 0, + desc->random_ip ^ (unsigned long) action); + migrate_enable(); + } wake_threads_waitq(desc); }