nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

random: remove unused tracepoints

Browse source 
These explicit tracepoints aren't really used and show sign of aging.
It's work to keep these up to date, and before I attempted to keep them
up to date, they weren't up to date, which indicates that they're not
really used. These days there are better ways of introspecting anyway.

Cc: Theodore Ts'o <tytso@mit.edu>
Reviewed-by: Dominik Brodowski <linux@dominikbrodowski.net>
Reviewed-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
This commit is contained in:
Jason A. Donenfeld 2022-02-10 16:40:44 +01:00
parent 95e6060c20
commit 14c174633f
3 changed files with 3 additions and 241 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

30
drivers/char/random.c
View file

@ -237,9 +237,6 @@
#include <asm/irq_regs.h> #include <asm/irq_regs.h>
#include <asm/io.h> #include <asm/io.h>
#define CREATE_TRACE_POINTS
#include <trace/events/random.h>
enum { enum {
POOL_BITS = BLAKE2S_HASH_SIZE * 8, POOL_BITS = BLAKE2S_HASH_SIZE * 8,
POOL_MIN_BITS = POOL_BITS /* No point in settling for less. */ POOL_MIN_BITS = POOL_BITS /* No point in settling for less. */
@ -315,7 +312,6 @@ static void mix_pool_bytes(const void *in, size_t nbytes)
{ {
unsigned long flags; unsigned long flags;
trace_mix_pool_bytes(nbytes, _RET_IP_);
spin_lock_irqsave(&input_pool.lock, flags); spin_lock_irqsave(&input_pool.lock, flags);
_mix_pool_bytes(in, nbytes); _mix_pool_bytes(in, nbytes);
spin_unlock_irqrestore(&input_pool.lock, flags); spin_unlock_irqrestore(&input_pool.lock, flags);
@ -389,8 +385,6 @@ static void credit_entropy_bits(size_t nbits)
entropy_count = min_t(unsigned int, POOL_BITS, orig + add); entropy_count = min_t(unsigned int, POOL_BITS, orig + add);
} while (cmpxchg(&input_pool.entropy_count, orig, entropy_count) != orig); } while (cmpxchg(&input_pool.entropy_count, orig, entropy_count) != orig);
trace_credit_entropy_bits(nbits, entropy_count, _RET_IP_);
if (crng_init < 2 && entropy_count >= POOL_MIN_BITS) if (crng_init < 2 && entropy_count >= POOL_MIN_BITS)
crng_reseed(); crng_reseed();
} }
@ -721,7 +715,6 @@ void add_device_randomness(const void *buf, size_t size)
if (!crng_ready() && size) if (!crng_ready() && size)
crng_slow_load(buf, size); crng_slow_load(buf, size);
trace_add_device_randomness(size, _RET_IP_);
spin_lock_irqsave(&input_pool.lock, flags); spin_lock_irqsave(&input_pool.lock, flags);
_mix_pool_bytes(buf, size); _mix_pool_bytes(buf, size);
_mix_pool_bytes(&time, sizeof(time)); _mix_pool_bytes(&time, sizeof(time));
@ -800,7 +793,6 @@ void add_input_randomness(unsigned int type, unsigned int code,
last_value = value; last_value = value;
add_timer_randomness(&input_timer_state, add_timer_randomness(&input_timer_state,
(type << 4) ^ code ^ (code >> 4) ^ value); (type << 4) ^ code ^ (code >> 4) ^ value);
trace_add_input_randomness(input_pool.entropy_count);
} }
EXPORT_SYMBOL_GPL(add_input_randomness); EXPORT_SYMBOL_GPL(add_input_randomness);
@ -880,7 +872,6 @@ void add_disk_randomness(struct gendisk *disk)
return; return;
/* first major is 1, so we get >= 0x200 here */ /* first major is 1, so we get >= 0x200 here */
add_timer_randomness(disk->random, 0x100 + disk_devt(disk)); add_timer_randomness(disk->random, 0x100 + disk_devt(disk));
trace_add_disk_randomness(disk_devt(disk), input_pool.entropy_count);
} }
EXPORT_SYMBOL_GPL(add_disk_randomness); EXPORT_SYMBOL_GPL(add_disk_randomness);
#endif #endif
@ -905,8 +896,6 @@ static void extract_entropy(void *buf, size_t nbytes)
} block; } block;
size_t i; size_t i;
trace_extract_entropy(nbytes, input_pool.entropy_count);
for (i = 0; i < ARRAY_SIZE(block.rdseed); ++i) { for (i = 0; i < ARRAY_SIZE(block.rdseed); ++i) {
if (!arch_get_random_seed_long(&block.rdseed[i]) && if (!arch_get_random_seed_long(&block.rdseed[i]) &&
!arch_get_random_long(&block.rdseed[i])) !arch_get_random_long(&block.rdseed[i]))
@ -978,8 +967,6 @@ static void _get_random_bytes(void *buf, size_t nbytes)
u8 tmp[CHACHA_BLOCK_SIZE]; u8 tmp[CHACHA_BLOCK_SIZE];
size_t len; size_t len;
trace_get_random_bytes(nbytes, _RET_IP_);
if (!nbytes) if (!nbytes)
return; return;
@ -1176,7 +1163,6 @@ size_t __must_check get_random_bytes_arch(void *buf, size_t nbytes)
size_t left = nbytes; size_t left = nbytes;
u8 *p = buf; u8 *p = buf;
trace_get_random_bytes_arch(left, _RET_IP_);
while (left) { while (left) {
unsigned long v; unsigned long v;
size_t chunk = min_t(size_t, left, sizeof(unsigned long)); size_t chunk = min_t(size_t, left, sizeof(unsigned long));
@ -1260,16 +1246,6 @@ void rand_initialize_disk(struct gendisk *disk)
} }
#endif #endif
static ssize_t urandom_read_nowarn(struct file *file, char __user *buf,
size_t nbytes, loff_t *ppos)
{
ssize_t ret;
ret = get_random_bytes_user(buf, nbytes);
trace_urandom_read(nbytes, input_pool.entropy_count);
return ret;
}
static ssize_t urandom_read(struct file *file, char __user *buf, size_t nbytes, static ssize_t urandom_read(struct file *file, char __user *buf, size_t nbytes,
loff_t *ppos) loff_t *ppos)
{ {
@ -1282,7 +1258,7 @@ static ssize_t urandom_read(struct file *file, char __user *buf, size_t nbytes,
current->comm, nbytes); current->comm, nbytes);
} }
return urandom_read_nowarn(file, buf, nbytes, ppos); return get_random_bytes_user(buf, nbytes);
} }
static ssize_t random_read(struct file *file, char __user *buf, size_t nbytes, static ssize_t random_read(struct file *file, char __user *buf, size_t nbytes,
@ -1293,7 +1269,7 @@ static ssize_t random_read(struct file *file, char __user *buf, size_t nbytes,
ret = wait_for_random_bytes(); ret = wait_for_random_bytes();
if (ret != 0) if (ret != 0)
return ret; return ret;
return urandom_read_nowarn(file, buf, nbytes, ppos); return get_random_bytes_user(buf, nbytes);
} }
static __poll_t random_poll(struct file *file, poll_table *wait) static __poll_t random_poll(struct file *file, poll_table *wait)
@ -1454,7 +1430,7 @@ SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count, unsigned int,
if (unlikely(ret)) if (unlikely(ret))
return ret; return ret;
} }
return urandom_read_nowarn(NULL, buf, count, NULL); return get_random_bytes_user(buf, count);
} }
/******************************************************************** /********************************************************************

212
include/trace/events/random.h
View file

@ -1,212 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM random
#if !defined(_TRACE_RANDOM_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_RANDOM_H
#include <linux/writeback.h>
#include <linux/tracepoint.h>
TRACE_EVENT(add_device_randomness,
TP_PROTO(size_t bytes, unsigned long IP),
TP_ARGS(bytes, IP),
TP_STRUCT__entry(
__field(size_t, bytes )
__field(unsigned long, IP )
),
TP_fast_assign(
__entry->bytes = bytes;
__entry->IP = IP;
),
TP_printk("bytes %zu caller %pS",
__entry->bytes, (void *)__entry->IP)
);
DECLARE_EVENT_CLASS(random__mix_pool_bytes,
TP_PROTO(size_t bytes, unsigned long IP),
TP_ARGS(bytes, IP),
TP_STRUCT__entry(
__field(size_t, bytes )
__field(unsigned long, IP )
),
TP_fast_assign(
__entry->bytes = bytes;
__entry->IP = IP;
),
TP_printk("input pool: bytes %zu caller %pS",
__entry->bytes, (void *)__entry->IP)
);
DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes,
TP_PROTO(size_t bytes, unsigned long IP),
TP_ARGS(bytes, IP)
);
DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock,
TP_PROTO(int bytes, unsigned long IP),
TP_ARGS(bytes, IP)
);
TRACE_EVENT(credit_entropy_bits,
TP_PROTO(size_t bits, size_t entropy_count, unsigned long IP),
TP_ARGS(bits, entropy_count, IP),
TP_STRUCT__entry(
__field(size_t, bits )
__field(size_t, entropy_count )
__field(unsigned long, IP )
),
TP_fast_assign(
__entry->bits = bits;
__entry->entropy_count = entropy_count;
__entry->IP = IP;
),
TP_printk("input pool: bits %zu entropy_count %zu caller %pS",
__entry->bits, __entry->entropy_count, (void *)__entry->IP)
);
TRACE_EVENT(add_input_randomness,
TP_PROTO(size_t input_bits),
TP_ARGS(input_bits),
TP_STRUCT__entry(
__field(size_t, input_bits )
),
TP_fast_assign(
__entry->input_bits = input_bits;
),
TP_printk("input_pool_bits %zu", __entry->input_bits)
);
TRACE_EVENT(add_disk_randomness,
TP_PROTO(dev_t dev, size_t input_bits),
TP_ARGS(dev, input_bits),
TP_STRUCT__entry(
__field(dev_t, dev )
__field(size_t, input_bits )
),
TP_fast_assign(
__entry->dev = dev;
__entry->input_bits = input_bits;
),
TP_printk("dev %d,%d input_pool_bits %zu", MAJOR(__entry->dev),
MINOR(__entry->dev), __entry->input_bits)
);
DECLARE_EVENT_CLASS(random__get_random_bytes,
TP_PROTO(size_t nbytes, unsigned long IP),
TP_ARGS(nbytes, IP),
TP_STRUCT__entry(
__field(size_t, nbytes )
__field(unsigned long, IP )
),
TP_fast_assign(
__entry->nbytes = nbytes;
__entry->IP = IP;
),
TP_printk("nbytes %zu caller %pS", __entry->nbytes, (void *)__entry->IP)
);
DEFINE_EVENT(random__get_random_bytes, get_random_bytes,
TP_PROTO(size_t nbytes, unsigned long IP),
TP_ARGS(nbytes, IP)
);
DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch,
TP_PROTO(size_t nbytes, unsigned long IP),
TP_ARGS(nbytes, IP)
);
DECLARE_EVENT_CLASS(random__extract_entropy,
TP_PROTO(size_t nbytes, size_t entropy_count),
TP_ARGS(nbytes, entropy_count),
TP_STRUCT__entry(
__field( size_t, nbytes )
__field( size_t, entropy_count )
),
TP_fast_assign(
__entry->nbytes = nbytes;
__entry->entropy_count = entropy_count;
),
TP_printk("input pool: nbytes %zu entropy_count %zu",
__entry->nbytes, __entry->entropy_count)
);
DEFINE_EVENT(random__extract_entropy, extract_entropy,
TP_PROTO(size_t nbytes, size_t entropy_count),
TP_ARGS(nbytes, entropy_count)
);
TRACE_EVENT(urandom_read,
TP_PROTO(size_t nbytes, size_t entropy_count),
TP_ARGS(nbytes, entropy_count),
TP_STRUCT__entry(
__field( size_t, nbytes )
__field( size_t, entropy_count )
),
TP_fast_assign(
__entry->nbytes = nbytes;
__entry->entropy_count = entropy_count;
),
TP_printk("reading: nbytes %zu entropy_count %zu",
__entry->nbytes, __entry->entropy_count)
);
TRACE_EVENT(prandom_u32,
TP_PROTO(unsigned int ret),
TP_ARGS(ret),
TP_STRUCT__entry(
__field( unsigned int, ret)
),
TP_fast_assign(
__entry->ret = ret;
),
TP_printk("ret=%u" , __entry->ret)
);
#endif /* _TRACE_RANDOM_H */
/* This part must be outside protection */
#include <trace/define_trace.h>

2
lib/random32.c
View file

@ -41,7 +41,6 @@
#include <linux/bitops.h> #include <linux/bitops.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
#include <trace/events/random.h>
/** /**
* prandom_u32_state - seeded pseudo-random number generator. * prandom_u32_state - seeded pseudo-random number generator.
@ -387,7 +386,6 @@ u32 prandom_u32(void)
struct siprand_state *state = get_cpu_ptr(&net_rand_state); struct siprand_state *state = get_cpu_ptr(&net_rand_state);
u32 res = siprand_u32(state); u32 res = siprand_u32(state);
trace_prandom_u32(res);
put_cpu_ptr(&net_rand_state); put_cpu_ptr(&net_rand_state);
return res; return res;
} }