From 186db26d05034df31e0ced1b8b5d7d62ebe39b8f Mon Sep 17 00:00:00 2001 From: Felix Fietkau Date: Sat, 24 Jan 2015 20:02:02 +0000 Subject: kernel: remove linux 3.3 patches and config Signed-off-by: Felix Fietkau SVN-Revision: 44109 --- .../generic/patches-3.3/050-rng_git_backport.patch | 783 --------------------- 1 file changed, 783 deletions(-) delete mode 100644 target/linux/generic/patches-3.3/050-rng_git_backport.patch (limited to 'target/linux/generic/patches-3.3/050-rng_git_backport.patch') diff --git a/target/linux/generic/patches-3.3/050-rng_git_backport.patch b/target/linux/generic/patches-3.3/050-rng_git_backport.patch deleted file mode 100644 index 825eb73a43..0000000000 --- a/target/linux/generic/patches-3.3/050-rng_git_backport.patch +++ /dev/null @@ -1,783 +0,0 @@ ---- a/drivers/char/random.c -+++ b/drivers/char/random.c -@@ -125,21 +125,26 @@ - * The current exported interfaces for gathering environmental noise - * from the devices are: - * -+ * void add_device_randomness(const void *buf, unsigned int size); - * void add_input_randomness(unsigned int type, unsigned int code, - * unsigned int value); -- * void add_interrupt_randomness(int irq); -+ * void add_interrupt_randomness(int irq, int irq_flags); - * void add_disk_randomness(struct gendisk *disk); - * - * add_input_randomness() uses the input layer interrupt timing, as well as - * the event type information from the hardware. - * -- * add_interrupt_randomness() uses the inter-interrupt timing as random -- * inputs to the entropy pool. Note that not all interrupts are good -- * sources of randomness! For example, the timer interrupts is not a -- * good choice, because the periodicity of the interrupts is too -- * regular, and hence predictable to an attacker. Network Interface -- * Controller interrupts are a better measure, since the timing of the -- * NIC interrupts are more unpredictable. -+ * add_interrupt_randomness() uses the interrupt timing as random -+ * inputs to the entropy pool. Using the cycle counters and the irq source -+ * as inputs, it feeds the randomness roughly once a second. -+ * -+ * add_device_randomness() is for adding data to the random pool that -+ * is likely to differ between two devices (or possibly even per boot). -+ * This would be things like MAC addresses or serial numbers, or the -+ * read-out of the RTC. This does *not* add any actual entropy to the -+ * pool, but it initializes the pool to different values for devices -+ * that might otherwise be identical and have very little entropy -+ * available to them (particularly common in the embedded world). - * - * add_disk_randomness() uses what amounts to the seek time of block - * layer request events, on a per-disk_devt basis, as input to the -@@ -248,6 +253,7 @@ - #include - #include - #include -+#include - - #ifdef CONFIG_GENERIC_HARDIRQS - # include -@@ -256,8 +262,12 @@ - #include - #include - #include -+#include - #include - -+#define CREATE_TRACE_POINTS -+#include -+ - /* - * Configuration information - */ -@@ -420,8 +430,10 @@ struct entropy_store { - /* read-write data: */ - spinlock_t lock; - unsigned add_ptr; -+ unsigned input_rotate; - int entropy_count; -- int input_rotate; -+ int entropy_total; -+ unsigned int initialized:1; - __u8 last_data[EXTRACT_SIZE]; - }; - -@@ -454,6 +466,10 @@ static struct entropy_store nonblocking_ - .pool = nonblocking_pool_data - }; - -+static __u32 const twist_table[8] = { -+ 0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158, -+ 0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 }; -+ - /* - * This function adds bytes into the entropy "pool". It does not - * update the entropy estimate. The caller should call -@@ -464,29 +480,24 @@ static struct entropy_store nonblocking_ - * it's cheap to do so and helps slightly in the expected case where - * the entropy is concentrated in the low-order bits. - */ --static void mix_pool_bytes_extract(struct entropy_store *r, const void *in, -- int nbytes, __u8 out[64]) -+static void _mix_pool_bytes(struct entropy_store *r, const void *in, -+ int nbytes, __u8 out[64]) - { -- static __u32 const twist_table[8] = { -- 0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158, -- 0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 }; - unsigned long i, j, tap1, tap2, tap3, tap4, tap5; - int input_rotate; - int wordmask = r->poolinfo->poolwords - 1; - const char *bytes = in; - __u32 w; -- unsigned long flags; - -- /* Taps are constant, so we can load them without holding r->lock. */ - tap1 = r->poolinfo->tap1; - tap2 = r->poolinfo->tap2; - tap3 = r->poolinfo->tap3; - tap4 = r->poolinfo->tap4; - tap5 = r->poolinfo->tap5; - -- spin_lock_irqsave(&r->lock, flags); -- input_rotate = r->input_rotate; -- i = r->add_ptr; -+ smp_rmb(); -+ input_rotate = ACCESS_ONCE(r->input_rotate); -+ i = ACCESS_ONCE(r->add_ptr); - - /* mix one byte at a time to simplify size handling and churn faster */ - while (nbytes--) { -@@ -513,19 +524,61 @@ static void mix_pool_bytes_extract(struc - input_rotate += i ? 7 : 14; - } - -- r->input_rotate = input_rotate; -- r->add_ptr = i; -+ ACCESS_ONCE(r->input_rotate) = input_rotate; -+ ACCESS_ONCE(r->add_ptr) = i; -+ smp_wmb(); - - if (out) - for (j = 0; j < 16; j++) - ((__u32 *)out)[j] = r->pool[(i - j) & wordmask]; -+} -+ -+static void __mix_pool_bytes(struct entropy_store *r, const void *in, -+ int nbytes, __u8 out[64]) -+{ -+ trace_mix_pool_bytes_nolock(r->name, nbytes, _RET_IP_); -+ _mix_pool_bytes(r, in, nbytes, out); -+} - -+static void mix_pool_bytes(struct entropy_store *r, const void *in, -+ int nbytes, __u8 out[64]) -+{ -+ unsigned long flags; -+ -+ trace_mix_pool_bytes(r->name, nbytes, _RET_IP_); -+ spin_lock_irqsave(&r->lock, flags); -+ _mix_pool_bytes(r, in, nbytes, out); - spin_unlock_irqrestore(&r->lock, flags); - } - --static void mix_pool_bytes(struct entropy_store *r, const void *in, int bytes) -+struct fast_pool { -+ __u32 pool[4]; -+ unsigned long last; -+ unsigned short count; -+ unsigned char rotate; -+ unsigned char last_timer_intr; -+}; -+ -+/* -+ * This is a fast mixing routine used by the interrupt randomness -+ * collector. It's hardcoded for an 128 bit pool and assumes that any -+ * locks that might be needed are taken by the caller. -+ */ -+static void fast_mix(struct fast_pool *f, const void *in, int nbytes) - { -- mix_pool_bytes_extract(r, in, bytes, NULL); -+ const char *bytes = in; -+ __u32 w; -+ unsigned i = f->count; -+ unsigned input_rotate = f->rotate; -+ -+ while (nbytes--) { -+ w = rol32(*bytes++, input_rotate & 31) ^ f->pool[i & 3] ^ -+ f->pool[(i + 1) & 3]; -+ f->pool[i & 3] = (w >> 3) ^ twist_table[w & 7]; -+ input_rotate += (i++ & 3) ? 7 : 14; -+ } -+ f->count = i; -+ f->rotate = input_rotate; - } - - /* -@@ -533,30 +586,38 @@ static void mix_pool_bytes(struct entrop - */ - static void credit_entropy_bits(struct entropy_store *r, int nbits) - { -- unsigned long flags; -- int entropy_count; -+ int entropy_count, orig; - - if (!nbits) - return; - -- spin_lock_irqsave(&r->lock, flags); -- - DEBUG_ENT("added %d entropy credits to %s\n", nbits, r->name); -- entropy_count = r->entropy_count; -+retry: -+ entropy_count = orig = ACCESS_ONCE(r->entropy_count); - entropy_count += nbits; -+ - if (entropy_count < 0) { - DEBUG_ENT("negative entropy/overflow\n"); - entropy_count = 0; - } else if (entropy_count > r->poolinfo->POOLBITS) - entropy_count = r->poolinfo->POOLBITS; -- r->entropy_count = entropy_count; -+ if (cmpxchg(&r->entropy_count, orig, entropy_count) != orig) -+ goto retry; -+ -+ if (!r->initialized && nbits > 0) { -+ r->entropy_total += nbits; -+ if (r->entropy_total > 128) -+ r->initialized = 1; -+ } -+ -+ trace_credit_entropy_bits(r->name, nbits, entropy_count, -+ r->entropy_total, _RET_IP_); - - /* should we wake readers? */ - if (r == &input_pool && entropy_count >= random_read_wakeup_thresh) { - wake_up_interruptible(&random_read_wait); - kill_fasync(&fasync, SIGIO, POLL_IN); - } -- spin_unlock_irqrestore(&r->lock, flags); - } - - /********************************************************************* -@@ -609,6 +670,25 @@ static void set_timer_rand_state(unsigne - } - #endif - -+/* -+ * Add device- or boot-specific data to the input and nonblocking -+ * pools to help initialize them to unique values. -+ * -+ * None of this adds any entropy, it is meant to avoid the -+ * problem of the nonblocking pool having similar initial state -+ * across largely identical devices. -+ */ -+void add_device_randomness(const void *buf, unsigned int size) -+{ -+ unsigned long time = get_cycles() ^ jiffies; -+ -+ mix_pool_bytes(&input_pool, buf, size, NULL); -+ mix_pool_bytes(&input_pool, &time, sizeof(time), NULL); -+ mix_pool_bytes(&nonblocking_pool, buf, size, NULL); -+ mix_pool_bytes(&nonblocking_pool, &time, sizeof(time), NULL); -+} -+EXPORT_SYMBOL(add_device_randomness); -+ - static struct timer_rand_state input_timer_state; - - /* -@@ -637,13 +717,9 @@ static void add_timer_randomness(struct - goto out; - - sample.jiffies = jiffies; -- -- /* Use arch random value, fall back to cycles */ -- if (!arch_get_random_int(&sample.cycles)) -- sample.cycles = get_cycles(); -- -+ sample.cycles = get_cycles(); - sample.num = num; -- mix_pool_bytes(&input_pool, &sample, sizeof(sample)); -+ mix_pool_bytes(&input_pool, &sample, sizeof(sample), NULL); - - /* - * Calculate number of bits of randomness we probably added. -@@ -700,17 +776,48 @@ void add_input_randomness(unsigned int t - } - EXPORT_SYMBOL_GPL(add_input_randomness); - --void add_interrupt_randomness(int irq) -+static DEFINE_PER_CPU(struct fast_pool, irq_randomness); -+ -+void add_interrupt_randomness(int irq, int irq_flags) - { -- struct timer_rand_state *state; -+ struct entropy_store *r; -+ struct fast_pool *fast_pool = &__get_cpu_var(irq_randomness); -+ struct pt_regs *regs = get_irq_regs(); -+ unsigned long now = jiffies; -+ __u32 input[4], cycles = get_cycles(); -+ -+ input[0] = cycles ^ jiffies; -+ input[1] = irq; -+ if (regs) { -+ __u64 ip = instruction_pointer(regs); -+ input[2] = ip; -+ input[3] = ip >> 32; -+ } - -- state = get_timer_rand_state(irq); -+ fast_mix(fast_pool, input, sizeof(input)); - -- if (state == NULL) -+ if ((fast_pool->count & 1023) && -+ !time_after(now, fast_pool->last + HZ)) - return; - -- DEBUG_ENT("irq event %d\n", irq); -- add_timer_randomness(state, 0x100 + irq); -+ fast_pool->last = now; -+ -+ r = nonblocking_pool.initialized ? &input_pool : &nonblocking_pool; -+ __mix_pool_bytes(r, &fast_pool->pool, sizeof(fast_pool->pool), NULL); -+ /* -+ * If we don't have a valid cycle counter, and we see -+ * back-to-back timer interrupts, then skip giving credit for -+ * any entropy. -+ */ -+ if (cycles == 0) { -+ if (irq_flags & __IRQF_TIMER) { -+ if (fast_pool->last_timer_intr) -+ return; -+ fast_pool->last_timer_intr = 1; -+ } else -+ fast_pool->last_timer_intr = 0; -+ } -+ credit_entropy_bits(r, 1); - } - - #ifdef CONFIG_BLOCK -@@ -742,7 +849,11 @@ static ssize_t extract_entropy(struct en - */ - static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes) - { -- __u32 tmp[OUTPUT_POOL_WORDS]; -+ union { -+ __u32 tmp[OUTPUT_POOL_WORDS]; -+ long hwrand[4]; -+ } u; -+ int i; - - if (r->pull && r->entropy_count < nbytes * 8 && - r->entropy_count < r->poolinfo->POOLBITS) { -@@ -753,17 +864,22 @@ static void xfer_secondary_pool(struct e - /* pull at least as many as BYTES as wakeup BITS */ - bytes = max_t(int, bytes, random_read_wakeup_thresh / 8); - /* but never more than the buffer size */ -- bytes = min_t(int, bytes, sizeof(tmp)); -+ bytes = min_t(int, bytes, sizeof(u.tmp)); - - DEBUG_ENT("going to reseed %s with %d bits " - "(%d of %d requested)\n", - r->name, bytes * 8, nbytes * 8, r->entropy_count); - -- bytes = extract_entropy(r->pull, tmp, bytes, -+ bytes = extract_entropy(r->pull, u.tmp, bytes, - random_read_wakeup_thresh / 8, rsvd); -- mix_pool_bytes(r, tmp, bytes); -+ mix_pool_bytes(r, u.tmp, bytes, NULL); - credit_entropy_bits(r, bytes*8); - } -+ for (i = 0; i < 4; i++) -+ if (arch_get_random_long(&u.hwrand[i])) -+ break; -+ if (i) -+ mix_pool_bytes(r, &u.hwrand, i * sizeof(u.hwrand[0]), 0); - } - - /* -@@ -822,9 +938,11 @@ static void extract_buf(struct entropy_s - int i; - __u32 hash[5], workspace[SHA_WORKSPACE_WORDS]; - __u8 extract[64]; -+ unsigned long flags; - - /* Generate a hash across the pool, 16 words (512 bits) at a time */ - sha_init(hash); -+ spin_lock_irqsave(&r->lock, flags); - for (i = 0; i < r->poolinfo->poolwords; i += 16) - sha_transform(hash, (__u8 *)(r->pool + i), workspace); - -@@ -837,7 +955,8 @@ static void extract_buf(struct entropy_s - * brute-forcing the feedback as hard as brute-forcing the - * hash. - */ -- mix_pool_bytes_extract(r, hash, sizeof(hash), extract); -+ __mix_pool_bytes(r, hash, sizeof(hash), extract); -+ spin_unlock_irqrestore(&r->lock, flags); - - /* - * To avoid duplicates, we atomically extract a portion of the -@@ -860,12 +979,12 @@ static void extract_buf(struct entropy_s - } - - static ssize_t extract_entropy(struct entropy_store *r, void *buf, -- size_t nbytes, int min, int reserved) -+ size_t nbytes, int min, int reserved) - { - ssize_t ret = 0, i; - __u8 tmp[EXTRACT_SIZE]; -- unsigned long flags; - -+ trace_extract_entropy(r->name, nbytes, r->entropy_count, _RET_IP_); - xfer_secondary_pool(r, nbytes); - nbytes = account(r, nbytes, min, reserved); - -@@ -873,6 +992,8 @@ static ssize_t extract_entropy(struct en - extract_buf(r, tmp); - - if (fips_enabled) { -+ unsigned long flags; -+ - spin_lock_irqsave(&r->lock, flags); - if (!memcmp(tmp, r->last_data, EXTRACT_SIZE)) - panic("Hardware RNG duplicated output!\n"); -@@ -898,6 +1019,7 @@ static ssize_t extract_entropy_user(stru - ssize_t ret = 0, i; - __u8 tmp[EXTRACT_SIZE]; - -+ trace_extract_entropy_user(r->name, nbytes, r->entropy_count, _RET_IP_); - xfer_secondary_pool(r, nbytes); - nbytes = account(r, nbytes, 0, 0); - -@@ -931,17 +1053,35 @@ static ssize_t extract_entropy_user(stru - - /* - * This function is the exported kernel interface. It returns some -- * number of good random numbers, suitable for seeding TCP sequence -- * numbers, etc. -+ * number of good random numbers, suitable for key generation, seeding -+ * TCP sequence numbers, etc. It does not use the hw random number -+ * generator, if available; use get_random_bytes_arch() for that. - */ - void get_random_bytes(void *buf, int nbytes) - { -+ extract_entropy(&nonblocking_pool, buf, nbytes, 0, 0); -+} -+EXPORT_SYMBOL(get_random_bytes); -+ -+/* -+ * This function will use the architecture-specific hardware random -+ * number generator if it is available. The arch-specific hw RNG will -+ * almost certainly be faster than what we can do in software, but it -+ * is impossible to verify that it is implemented securely (as -+ * opposed, to, say, the AES encryption of a sequence number using a -+ * key known by the NSA). So it's useful if we need the speed, but -+ * only if we're willing to trust the hardware manufacturer not to -+ * have put in a back door. -+ */ -+void get_random_bytes_arch(void *buf, int nbytes) -+{ - char *p = buf; - -+ trace_get_random_bytes(nbytes, _RET_IP_); - while (nbytes) { - unsigned long v; - int chunk = min(nbytes, (int)sizeof(unsigned long)); -- -+ - if (!arch_get_random_long(&v)) - break; - -@@ -950,9 +1090,11 @@ void get_random_bytes(void *buf, int nby - nbytes -= chunk; - } - -- extract_entropy(&nonblocking_pool, p, nbytes, 0, 0); -+ if (nbytes) -+ extract_entropy(&nonblocking_pool, p, nbytes, 0, 0); - } --EXPORT_SYMBOL(get_random_bytes); -+EXPORT_SYMBOL(get_random_bytes_arch); -+ - - /* - * init_std_data - initialize pool with system data -@@ -966,21 +1108,18 @@ EXPORT_SYMBOL(get_random_bytes); - static void init_std_data(struct entropy_store *r) - { - int i; -- ktime_t now; -- unsigned long flags; -+ ktime_t now = ktime_get_real(); -+ unsigned long rv; - -- spin_lock_irqsave(&r->lock, flags); - r->entropy_count = 0; -- spin_unlock_irqrestore(&r->lock, flags); -- -- now = ktime_get_real(); -- mix_pool_bytes(r, &now, sizeof(now)); -- for (i = r->poolinfo->POOLBYTES; i > 0; i -= sizeof flags) { -- if (!arch_get_random_long(&flags)) -+ r->entropy_total = 0; -+ mix_pool_bytes(r, &now, sizeof(now), NULL); -+ for (i = r->poolinfo->POOLBYTES; i > 0; i -= sizeof(rv)) { -+ if (!arch_get_random_long(&rv)) - break; -- mix_pool_bytes(r, &flags, sizeof(flags)); -+ mix_pool_bytes(r, &rv, sizeof(rv), NULL); - } -- mix_pool_bytes(r, utsname(), sizeof(*(utsname()))); -+ mix_pool_bytes(r, utsname(), sizeof(*(utsname())), NULL); - } - - static int rand_initialize(void) -@@ -1117,7 +1256,7 @@ write_pool(struct entropy_store *r, cons - count -= bytes; - p += bytes; - -- mix_pool_bytes(r, buf, bytes); -+ mix_pool_bytes(r, buf, bytes, NULL); - cond_resched(); - } - -@@ -1274,6 +1413,7 @@ static int proc_do_uuid(ctl_table *table - } - - static int sysctl_poolsize = INPUT_POOL_WORDS * 32; -+extern ctl_table random_table[]; - ctl_table random_table[] = { - { - .procname = "poolsize", -@@ -1339,7 +1479,7 @@ late_initcall(random_int_secret_init); - * value is not cryptographically secure but for several uses the cost of - * depleting entropy is too high - */ --DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash); -+static DEFINE_PER_CPU(__u32 [MD5_DIGEST_WORDS], get_random_int_hash); - unsigned int get_random_int(void) - { - __u32 *hash; ---- a/drivers/mfd/ab3100-core.c -+++ b/drivers/mfd/ab3100-core.c -@@ -409,8 +409,6 @@ static irqreturn_t ab3100_irq_handler(in - u32 fatevent; - int err; - -- add_interrupt_randomness(irq); -- - err = ab3100_get_register_page_interruptible(ab3100, AB3100_EVENTA1, - event_regs, 3); - if (err) ---- a/drivers/usb/core/hub.c -+++ b/drivers/usb/core/hub.c -@@ -24,6 +24,7 @@ - #include - #include - #include -+#include - - #include - #include -@@ -1896,6 +1897,14 @@ int usb_new_device(struct usb_device *ud - /* Tell the world! */ - announce_device(udev); - -+ if (udev->serial) -+ add_device_randomness(udev->serial, strlen(udev->serial)); -+ if (udev->product) -+ add_device_randomness(udev->product, strlen(udev->product)); -+ if (udev->manufacturer) -+ add_device_randomness(udev->manufacturer, -+ strlen(udev->manufacturer)); -+ - device_enable_async_suspend(&udev->dev); - /* Register the device. The device driver is responsible - * for configuring the device and invoking the add-device ---- a/include/linux/random.h -+++ b/include/linux/random.h -@@ -50,11 +50,13 @@ struct rnd_state { - - extern void rand_initialize_irq(int irq); - -+extern void add_device_randomness(const void *, unsigned int); - extern void add_input_randomness(unsigned int type, unsigned int code, - unsigned int value); --extern void add_interrupt_randomness(int irq); -+extern void add_interrupt_randomness(int irq, int irq_flags); - - extern void get_random_bytes(void *buf, int nbytes); -+extern void get_random_bytes_arch(void *buf, int nbytes); - void generate_random_uuid(unsigned char uuid_out[16]); - - #ifndef MODULE ---- /dev/null -+++ b/include/trace/events/random.h -@@ -0,0 +1,134 @@ -+#undef TRACE_SYSTEM -+#define TRACE_SYSTEM random -+ -+#if !defined(_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ) -+#define _TRACE_RANDOM_H -+ -+#include -+#include -+ -+DECLARE_EVENT_CLASS(random__mix_pool_bytes, -+ TP_PROTO(const char *pool_name, int bytes, unsigned long IP), -+ -+ TP_ARGS(pool_name, bytes, IP), -+ -+ TP_STRUCT__entry( -+ __field( const char *, pool_name ) -+ __field( int, bytes ) -+ __field(unsigned long, IP ) -+ ), -+ -+ TP_fast_assign( -+ __entry->pool_name = pool_name; -+ __entry->bytes = bytes; -+ __entry->IP = IP; -+ ), -+ -+ TP_printk("%s pool: bytes %d caller %pF", -+ __entry->pool_name, __entry->bytes, (void *)__entry->IP) -+); -+ -+DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, -+ TP_PROTO(const char *pool_name, int bytes, unsigned long IP), -+ -+ TP_ARGS(pool_name, bytes, IP) -+); -+ -+DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, -+ TP_PROTO(const char *pool_name, int bytes, unsigned long IP), -+ -+ TP_ARGS(pool_name, bytes, IP) -+); -+ -+TRACE_EVENT(credit_entropy_bits, -+ TP_PROTO(const char *pool_name, int bits, int entropy_count, -+ int entropy_total, unsigned long IP), -+ -+ TP_ARGS(pool_name, bits, entropy_count, entropy_total, IP), -+ -+ TP_STRUCT__entry( -+ __field( const char *, pool_name ) -+ __field( int, bits ) -+ __field( int, entropy_count ) -+ __field( int, entropy_total ) -+ __field(unsigned long, IP ) -+ ), -+ -+ TP_fast_assign( -+ __entry->pool_name = pool_name; -+ __entry->bits = bits; -+ __entry->entropy_count = entropy_count; -+ __entry->entropy_total = entropy_total; -+ __entry->IP = IP; -+ ), -+ -+ TP_printk("%s pool: bits %d entropy_count %d entropy_total %d " -+ "caller %pF", __entry->pool_name, __entry->bits, -+ __entry->entropy_count, __entry->entropy_total, -+ (void *)__entry->IP) -+); -+ -+TRACE_EVENT(get_random_bytes, -+ TP_PROTO(int nbytes, unsigned long IP), -+ -+ TP_ARGS(nbytes, IP), -+ -+ TP_STRUCT__entry( -+ __field( int, nbytes ) -+ __field(unsigned long, IP ) -+ ), -+ -+ TP_fast_assign( -+ __entry->nbytes = nbytes; -+ __entry->IP = IP; -+ ), -+ -+ TP_printk("nbytes %d caller %pF", __entry->nbytes, (void *)__entry->IP) -+); -+ -+DECLARE_EVENT_CLASS(random__extract_entropy, -+ TP_PROTO(const char *pool_name, int nbytes, int entropy_count, -+ unsigned long IP), -+ -+ TP_ARGS(pool_name, nbytes, entropy_count, IP), -+ -+ TP_STRUCT__entry( -+ __field( const char *, pool_name ) -+ __field( int, nbytes ) -+ __field( int, entropy_count ) -+ __field(unsigned long, IP ) -+ ), -+ -+ TP_fast_assign( -+ __entry->pool_name = pool_name; -+ __entry->nbytes = nbytes; -+ __entry->entropy_count = entropy_count; -+ __entry->IP = IP; -+ ), -+ -+ TP_printk("%s pool: nbytes %d entropy_count %d caller %pF", -+ __entry->pool_name, __entry->nbytes, __entry->entropy_count, -+ (void *)__entry->IP) -+); -+ -+ -+DEFINE_EVENT(random__extract_entropy, extract_entropy, -+ TP_PROTO(const char *pool_name, int nbytes, int entropy_count, -+ unsigned long IP), -+ -+ TP_ARGS(pool_name, nbytes, entropy_count, IP) -+); -+ -+DEFINE_EVENT(random__extract_entropy, extract_entropy_user, -+ TP_PROTO(const char *pool_name, int nbytes, int entropy_count, -+ unsigned long IP), -+ -+ TP_ARGS(pool_name, nbytes, entropy_count, IP) -+); -+ -+ -+ -+#endif /* _TRACE_RANDOM_H */ -+ -+/* This part must be outside protection */ -+#include ---- a/kernel/irq/handle.c -+++ b/kernel/irq/handle.c -@@ -117,7 +117,7 @@ irqreturn_t - handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action) - { - irqreturn_t retval = IRQ_NONE; -- unsigned int random = 0, irq = desc->irq_data.irq; -+ unsigned int flags = 0, irq = desc->irq_data.irq; - - do { - irqreturn_t res; -@@ -145,7 +145,7 @@ handle_irq_event_percpu(struct irq_desc - - /* Fall through to add to randomness */ - case IRQ_HANDLED: -- random |= action->flags; -+ flags |= action->flags; - break; - - default: -@@ -156,8 +156,7 @@ handle_irq_event_percpu(struct irq_desc - action = action->next; - } while (action); - -- if (random & IRQF_SAMPLE_RANDOM) -- add_interrupt_randomness(irq); -+ add_interrupt_randomness(irq, flags); - - if (!noirqdebug) - note_interrupt(irq, desc, retval); ---- a/net/core/dev.c -+++ b/net/core/dev.c -@@ -1176,6 +1176,7 @@ static int __dev_open(struct net_device - net_dmaengine_get(); - dev_set_rx_mode(dev); - dev_activate(dev); -+ add_device_randomness(dev->dev_addr, dev->addr_len); - } - - return ret; -@@ -4823,6 +4824,7 @@ int dev_set_mac_address(struct net_devic - err = ops->ndo_set_mac_address(dev, sa); - if (!err) - call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); -+ add_device_randomness(dev->dev_addr, dev->addr_len); - return err; - } - EXPORT_SYMBOL(dev_set_mac_address); -@@ -5602,6 +5604,7 @@ int register_netdevice(struct net_device - dev_init_scheduler(dev); - dev_hold(dev); - list_netdevice(dev); -+ add_device_randomness(dev->dev_addr, dev->addr_len); - - /* Notify protocols, that a new device appeared. */ - ret = call_netdevice_notifiers(NETDEV_REGISTER, dev); ---- a/net/core/rtnetlink.c -+++ b/net/core/rtnetlink.c -@@ -1371,6 +1371,7 @@ static int do_setlink(struct net_device - goto errout; - send_addr_notify = 1; - modified = 1; -+ add_device_randomness(dev->dev_addr, dev->addr_len); - } - - if (tb[IFLA_MTU]) { -- cgit v1.2.3