Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 11e8da38 authored by Jason A. Donenfeld's avatar Jason A. Donenfeld Committed by Greg Kroah-Hartman
Browse files

random: remove unused tracepoints 



commit 14c174633f349cb41ea90c2c0aaddac157012f74 upstream.

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: default avatarDominik Brodowski <linux@dominikbrodowski.net>
Reviewed-by: default avatarEric Biggers <ebiggers@google.com>
Signed-off-by: default avatarJason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 0c877142

drivers/char/random.c

+3 −27
Original line number Diff line number Diff line
@@ -238,9 +238,6 @@ 
#include <asm/irq_regs.h>

#include <asm/io.h>



#define CREATE_TRACE_POINTS

#include <trace/events/random.h>



enum {

	POOL_BITS = BLAKE2S_HASH_SIZE * 8,

	POOL_MIN_BITS = POOL_BITS /* No point in settling for less. */
@@ -316,7 +313,6 @@ static void mix_pool_bytes(const void *in, size_t nbytes) 
{

	unsigned long flags;



	trace_mix_pool_bytes(nbytes, _RET_IP_);

	spin_lock_irqsave(&input_pool.lock, flags);

	_mix_pool_bytes(in, nbytes);

	spin_unlock_irqrestore(&input_pool.lock, flags);
@@ -390,8 +386,6 @@ static void credit_entropy_bits(size_t nbits) 
		entropy_count = min_t(unsigned int, POOL_BITS, orig + add);

	} 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)

		crng_reseed();

}
@@ -771,7 +765,6 @@ void add_device_randomness(const void *buf, size_t size) 
	if (!crng_ready() && size)

		crng_slow_load(buf, size);



	trace_add_device_randomness(size, _RET_IP_);

	spin_lock_irqsave(&input_pool.lock, flags);

	_mix_pool_bytes(buf, size);

	_mix_pool_bytes(&time, sizeof(time));
@@ -850,7 +843,6 @@ void add_input_randomness(unsigned int type, unsigned int code, 
	last_value = value;

	add_timer_randomness(&input_timer_state,

			     (type << 4) ^ code ^ (code >> 4) ^ value);

	trace_add_input_randomness(input_pool.entropy_count);

}

EXPORT_SYMBOL_GPL(add_input_randomness);
@@ -930,7 +922,6 @@ void add_disk_randomness(struct gendisk *disk) 
		return;

	/* first major is 1, so we get >= 0x200 here */

	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);

#endif
@@ -955,8 +946,6 @@ static void extract_entropy(void *buf, size_t nbytes) 
	} block;

	size_t i;



	trace_extract_entropy(nbytes, input_pool.entropy_count);



	for (i = 0; i < ARRAY_SIZE(block.rdseed); ++i) {

		if (!arch_get_random_seed_long(&block.rdseed[i]) &&

		    !arch_get_random_long(&block.rdseed[i]))
@@ -1028,8 +1017,6 @@ static void _get_random_bytes(void *buf, size_t nbytes) 
	u8 tmp[CHACHA20_BLOCK_SIZE];

	size_t len;



	trace_get_random_bytes(nbytes, _RET_IP_);



	if (!nbytes)

		return;
@@ -1226,7 +1213,6 @@ size_t __must_check get_random_bytes_arch(void *buf, size_t nbytes) 
	size_t left = nbytes;

	u8 *p = buf;



	trace_get_random_bytes_arch(left, _RET_IP_);

	while (left) {

		unsigned long v;

		size_t chunk = min_t(size_t, left, sizeof(unsigned long));
@@ -1310,16 +1296,6 @@ void rand_initialize_disk(struct gendisk *disk) 
}

#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,

			    loff_t *ppos)

{
@@ -1332,7 +1308,7 @@ static ssize_t urandom_read(struct file *file, char __user *buf, size_t 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,
@@ -1343,7 +1319,7 @@ static ssize_t random_read(struct file *file, char __user *buf, size_t nbytes, 
	ret = wait_for_random_bytes();

	if (ret != 0)

		return ret;

	return urandom_read_nowarn(file, buf, nbytes, ppos);

	return get_random_bytes_user(buf, nbytes);

}



static unsigned int random_poll(struct file *file, poll_table *wait)
@@ -1502,7 +1478,7 @@ SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count, unsigned int, 
		if (unlikely(ret))

			return ret;

	}

	return urandom_read_nowarn(NULL, buf, count, NULL);

	return get_random_bytes_user(buf, count);

}



/********************************************************************

include/trace/events/random.h

deleted100644 → 0
+0 −194
Original line number Diff line number Diff line 
#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)

);



#endif /* _TRACE_RANDOM_H */



/* This part must be outside protection */

#include <trace/define_trace.h>

lib/random32.c

+2 −0
Original line number Diff line number Diff line
@@ -37,6 +37,8 @@ 
#include <linux/jiffies.h>

#include <linux/random.h>

#include <linux/sched.h>

#include <linux/bitops.h>

#include <linux/slab.h>

#include <asm/unaligned.h>



/**