/* SPDX-License-Identifier: GPL-2.0 OR BSD-2-Clause *//* * Test interface for Jitter RNG. * * Copyright (C) 2023, Stephan Mueller <smueller@chronox.de> */ #include <linux/debugfs.h>#include <linux/module.h>#include <linux/uaccess.h> #include "jitterentropy.h" #define JENT_TEST_RINGBUFFER_SIZE	(1<<10)#define JENT_TEST_RINGBUFFER_MASK	(JENT_TEST_RINGBUFFER_SIZE - 1) struct jent_testing {	u64 jent_testing_rb[JENT_TEST_RINGBUFFER_SIZE];	u32 rb_reader;	atomic_t rb_writer;	atomic_t jent_testing_enabled;	spinlock_t lock;	wait_queue_head_t read_wait;}; static struct dentry *jent_raw_debugfs_root = NULL; /*************************** Generic Data Handling ****************************/ /* * boot variable: * 0 ==> No boot test, gathering of runtime data allowed * 1 ==> Boot test enabled and ready for collecting data, gathering runtime *	 data is disabled * 2 ==> Boot test completed and disabled, gathering of runtime data is *	 disabled */ static void jent_testing_reset(struct jent_testing *data){	unsigned long flags; 	spin_lock_irqsave(&data->lock, flags);	data->rb_reader = 0;	atomic_set(&data->rb_writer, 0);	spin_unlock_irqrestore(&data->lock, flags);} static void jent_testing_data_init(struct jent_testing *data, u32 boot){	/*	 * The boot time testing implies we have a running test. If the	 * caller wants to clear it, he has to unset the boot_test flag	 * at runtime via sysfs to enable regular runtime testing	 */	if (boot)		return; 	jent_testing_reset(data);	atomic_set(&data->jent_testing_enabled, 1);	pr_warn("Enabling data collection\n");} static void jent_testing_fini(struct jent_testing *data, u32 boot){	/* If we have boot data, we do not reset yet to allow data to be read */	if (boot)		return; 	atomic_set(&data->jent_testing_enabled, 0);	jent_testing_reset(data);	pr_warn("Disabling data collection\n");} static bool jent_testing_store(struct jent_testing *data, u64 value,			       u32 *boot){	unsigned long flags; 	if (!atomic_read(&data->jent_testing_enabled) && (*boot != 1))		return false; 	spin_lock_irqsave(&data->lock, flags); 	/*	 * Disable entropy testing for boot time testing after ring buffer	 * is filled.	 */	if (*boot) {		if (((u32)atomic_read(&data->rb_writer)) >		     JENT_TEST_RINGBUFFER_SIZE) {			*boot = 2;			pr_warn_once("One time data collection test disabled\n");			spin_unlock_irqrestore(&data->lock, flags);			return false;		} 		if (atomic_read(&data->rb_writer) == 1)			pr_warn("One time data collection test enabled\n");	} 	data->jent_testing_rb[((u32)atomic_read(&data->rb_writer)) &			      JENT_TEST_RINGBUFFER_MASK] = value;	atomic_inc(&data->rb_writer); 	spin_unlock_irqrestore(&data->lock, flags); 	if (wq_has_sleeper(&data->read_wait))		wake_up_interruptible(&data->read_wait); 	return true;} static bool jent_testing_have_data(struct jent_testing *data){	return ((((u32)atomic_read(&data->rb_writer)) &		 JENT_TEST_RINGBUFFER_MASK) !=		 (data->rb_reader & JENT_TEST_RINGBUFFER_MASK));} static int jent_testing_reader(struct jent_testing *data, u32 *boot,			       u8 *outbuf, u32 outbuflen){	unsigned long flags;	int collected_data = 0; 	jent_testing_data_init(data, *boot); 	while (outbuflen) {		u32 writer = (u32)atomic_read(&data->rb_writer); 		spin_lock_irqsave(&data->lock, flags); 		/* We have no data or reached the writer. */		if (!writer || (writer == data->rb_reader)) { 			spin_unlock_irqrestore(&data->lock, flags); 			/*			 * Now we gathered all boot data, enable regular data			 * collection.			 */			if (*boot) {				*boot = 0;				goto out;			} 			wait_event_interruptible(data->read_wait,						 jent_testing_have_data(data));			if (signal_pending(current)) {				collected_data = -ERESTARTSYS;				goto out;			} 			continue;		} 		/* We copy out word-wise */		if (outbuflen < sizeof(u64)) {			spin_unlock_irqrestore(&data->lock, flags);			goto out;		} 		memcpy(outbuf, &data->jent_testing_rb[data->rb_reader],		       sizeof(u64));		data->rb_reader++; 		spin_unlock_irqrestore(&data->lock, flags); 		outbuf += sizeof(u64);		outbuflen -= sizeof(u64);		collected_data += sizeof(u64);	} out:	jent_testing_fini(data, *boot);	return collected_data;} static int jent_testing_extract_user(struct file *file, char __user *buf,				     size_t nbytes, loff_t *ppos,				     int (*reader)(u8 *outbuf, u32 outbuflen)){	u8 *tmp, *tmp_aligned;	int ret = 0, large_request = (nbytes > 256); 	if (!nbytes)		return 0; 	/*	 * The intention of this interface is for collecting at least	 * 1000 samples due to the SP800-90B requirements. However, due to	 * memory and performance constraints, it is not desirable to allocate	 * 8000 bytes of memory. Instead, we allocate space for only 125	 * samples, which will allow the user to collect all 1000 samples using	 * 8 calls to this interface.	 */	tmp = kmalloc(125 * sizeof(u64) + sizeof(u64), GFP_KERNEL);	if (!tmp)		return -ENOMEM; 	tmp_aligned = PTR_ALIGN(tmp, sizeof(u64)); 	while (nbytes) {		int i; 		if (large_request && need_resched()) {			if (signal_pending(current)) {				if (ret == 0)					ret = -ERESTARTSYS;				break;			}			schedule();		} 		i = min_t(int, nbytes, 125 * sizeof(u64));		i = reader(tmp_aligned, i);		if (i <= 0) {			if (i < 0)				ret = i;			break;		}		if (copy_to_user(buf, tmp_aligned, i)) {			ret = -EFAULT;			break;		} 		nbytes -= i;		buf += i;		ret += i;	} 	kfree_sensitive(tmp); 	if (ret > 0)		*ppos += ret; 	return ret;} /************** Raw High-Resolution Timer Entropy Data Handling **************/ static u32 boot_raw_hires_test = 0;module_param(boot_raw_hires_test, uint, 0644);MODULE_PARM_DESC(boot_raw_hires_test,		 "Enable gathering boot time high resolution timer entropy of the first Jitter RNG entropy events"); static struct jent_testing jent_raw_hires = {	.rb_reader = 0,	.rb_writer = ATOMIC_INIT(0),	.lock      = __SPIN_LOCK_UNLOCKED(jent_raw_hires.lock),	.read_wait = __WAIT_QUEUE_HEAD_INITIALIZER(jent_raw_hires.read_wait)}; int jent_raw_hires_entropy_store(__u64 value){	return jent_testing_store(&jent_raw_hires, value, &boot_raw_hires_test);}EXPORT_SYMBOL(jent_raw_hires_entropy_store); static int jent_raw_hires_entropy_reader(u8 *outbuf, u32 outbuflen){	return jent_testing_reader(&jent_raw_hires, &boot_raw_hires_test,				   outbuf, outbuflen);} static ssize_t jent_raw_hires_read(struct file *file, char __user *to,				   size_t count, loff_t *ppos){	return jent_testing_extract_user(file, to, count, ppos,					 jent_raw_hires_entropy_reader);} static const struct file_operations jent_raw_hires_fops = {	.owner = THIS_MODULE,	.read = jent_raw_hires_read,}; /******************************* Initialization *******************************/ void jent_testing_init(void){	jent_raw_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL); 	debugfs_create_file_unsafe("jent_raw_hires", 0400,				   jent_raw_debugfs_root, NULL,				   &jent_raw_hires_fops);}EXPORT_SYMBOL(jent_testing_init); void jent_testing_exit(void){	debugfs_remove_recursive(jent_raw_debugfs_root);}EXPORT_SYMBOL(jent_testing_exit);