1 /* SPDX-License-Identifier: GPL-2.0 OR BSD-2-Clause */
2 /*
3  * Test interface for Jitter RNG.
4  *
5  * Copyright (C) 2023, Stephan Mueller <smueller@chronox.de>
6  */
7 
8 #include <linux/debugfs.h>
9 #include <linux/module.h>
10 #include <linux/uaccess.h>
11 
12 #include "jitterentropy.h"
13 
14 #define JENT_TEST_RINGBUFFER_SIZE	(1<<10)
15 #define JENT_TEST_RINGBUFFER_MASK	(JENT_TEST_RINGBUFFER_SIZE - 1)
16 
17 struct jent_testing {
18 	u32 jent_testing_rb[JENT_TEST_RINGBUFFER_SIZE];
19 	u32 rb_reader;
20 	atomic_t rb_writer;
21 	atomic_t jent_testing_enabled;
22 	spinlock_t lock;
23 	wait_queue_head_t read_wait;
24 };
25 
26 static struct dentry *jent_raw_debugfs_root = NULL;
27 
28 /*************************** Generic Data Handling ****************************/
29 
30 /*
31  * boot variable:
32  * 0 ==> No boot test, gathering of runtime data allowed
33  * 1 ==> Boot test enabled and ready for collecting data, gathering runtime
34  *	 data is disabled
35  * 2 ==> Boot test completed and disabled, gathering of runtime data is
36  *	 disabled
37  */
38 
39 static void jent_testing_reset(struct jent_testing *data)
40 {
41 	unsigned long flags;
42 
43 	spin_lock_irqsave(&data->lock, flags);
44 	data->rb_reader = 0;
45 	atomic_set(&data->rb_writer, 0);
46 	spin_unlock_irqrestore(&data->lock, flags);
47 }
48 
49 static void jent_testing_data_init(struct jent_testing *data, u32 boot)
50 {
51 	/*
52 	 * The boot time testing implies we have a running test. If the
53 	 * caller wants to clear it, he has to unset the boot_test flag
54 	 * at runtime via sysfs to enable regular runtime testing
55 	 */
56 	if (boot)
57 		return;
58 
59 	jent_testing_reset(data);
60 	atomic_set(&data->jent_testing_enabled, 1);
61 	pr_warn("Enabling data collection\n");
62 }
63 
64 static void jent_testing_fini(struct jent_testing *data, u32 boot)
65 {
66 	/* If we have boot data, we do not reset yet to allow data to be read */
67 	if (boot)
68 		return;
69 
70 	atomic_set(&data->jent_testing_enabled, 0);
71 	jent_testing_reset(data);
72 	pr_warn("Disabling data collection\n");
73 }
74 
75 static bool jent_testing_store(struct jent_testing *data, u32 value,
76 			       u32 *boot)
77 {
78 	unsigned long flags;
79 
80 	if (!atomic_read(&data->jent_testing_enabled) && (*boot != 1))
81 		return false;
82 
83 	spin_lock_irqsave(&data->lock, flags);
84 
85 	/*
86 	 * Disable entropy testing for boot time testing after ring buffer
87 	 * is filled.
88 	 */
89 	if (*boot) {
90 		if (((u32)atomic_read(&data->rb_writer)) >
91 		     JENT_TEST_RINGBUFFER_SIZE) {
92 			*boot = 2;
93 			pr_warn_once("One time data collection test disabled\n");
94 			spin_unlock_irqrestore(&data->lock, flags);
95 			return false;
96 		}
97 
98 		if (atomic_read(&data->rb_writer) == 1)
99 			pr_warn("One time data collection test enabled\n");
100 	}
101 
102 	data->jent_testing_rb[((u32)atomic_read(&data->rb_writer)) &
103 			      JENT_TEST_RINGBUFFER_MASK] = value;
104 	atomic_inc(&data->rb_writer);
105 
106 	spin_unlock_irqrestore(&data->lock, flags);
107 
108 	if (wq_has_sleeper(&data->read_wait))
109 		wake_up_interruptible(&data->read_wait);
110 
111 	return true;
112 }
113 
114 static bool jent_testing_have_data(struct jent_testing *data)
115 {
116 	return ((((u32)atomic_read(&data->rb_writer)) &
117 		 JENT_TEST_RINGBUFFER_MASK) !=
118 		 (data->rb_reader & JENT_TEST_RINGBUFFER_MASK));
119 }
120 
121 static int jent_testing_reader(struct jent_testing *data, u32 *boot,
122 			       u8 *outbuf, u32 outbuflen)
123 {
124 	unsigned long flags;
125 	int collected_data = 0;
126 
127 	jent_testing_data_init(data, *boot);
128 
129 	while (outbuflen) {
130 		u32 writer = (u32)atomic_read(&data->rb_writer);
131 
132 		spin_lock_irqsave(&data->lock, flags);
133 
134 		/* We have no data or reached the writer. */
135 		if (!writer || (writer == data->rb_reader)) {
136 
137 			spin_unlock_irqrestore(&data->lock, flags);
138 
139 			/*
140 			 * Now we gathered all boot data, enable regular data
141 			 * collection.
142 			 */
143 			if (*boot) {
144 				*boot = 0;
145 				goto out;
146 			}
147 
148 			wait_event_interruptible(data->read_wait,
149 						 jent_testing_have_data(data));
150 			if (signal_pending(current)) {
151 				collected_data = -ERESTARTSYS;
152 				goto out;
153 			}
154 
155 			continue;
156 		}
157 
158 		/* We copy out word-wise */
159 		if (outbuflen < sizeof(u32)) {
160 			spin_unlock_irqrestore(&data->lock, flags);
161 			goto out;
162 		}
163 
164 		memcpy(outbuf, &data->jent_testing_rb[data->rb_reader],
165 		       sizeof(u32));
166 		data->rb_reader++;
167 
168 		spin_unlock_irqrestore(&data->lock, flags);
169 
170 		outbuf += sizeof(u32);
171 		outbuflen -= sizeof(u32);
172 		collected_data += sizeof(u32);
173 	}
174 
175 out:
176 	jent_testing_fini(data, *boot);
177 	return collected_data;
178 }
179 
180 static int jent_testing_extract_user(struct file *file, char __user *buf,
181 				     size_t nbytes, loff_t *ppos,
182 				     int (*reader)(u8 *outbuf, u32 outbuflen))
183 {
184 	u8 *tmp, *tmp_aligned;
185 	int ret = 0, large_request = (nbytes > 256);
186 
187 	if (!nbytes)
188 		return 0;
189 
190 	/*
191 	 * The intention of this interface is for collecting at least
192 	 * 1000 samples due to the SP800-90B requirements. So, we make no
193 	 * effort in avoiding allocating more memory that actually needed
194 	 * by the user. Hence, we allocate sufficient memory to always hold
195 	 * that amount of data.
196 	 */
197 	tmp = kmalloc(JENT_TEST_RINGBUFFER_SIZE + sizeof(u32), GFP_KERNEL);
198 	if (!tmp)
199 		return -ENOMEM;
200 
201 	tmp_aligned = PTR_ALIGN(tmp, sizeof(u32));
202 
203 	while (nbytes) {
204 		int i;
205 
206 		if (large_request && need_resched()) {
207 			if (signal_pending(current)) {
208 				if (ret == 0)
209 					ret = -ERESTARTSYS;
210 				break;
211 			}
212 			schedule();
213 		}
214 
215 		i = min_t(int, nbytes, JENT_TEST_RINGBUFFER_SIZE);
216 		i = reader(tmp_aligned, i);
217 		if (i <= 0) {
218 			if (i < 0)
219 				ret = i;
220 			break;
221 		}
222 		if (copy_to_user(buf, tmp_aligned, i)) {
223 			ret = -EFAULT;
224 			break;
225 		}
226 
227 		nbytes -= i;
228 		buf += i;
229 		ret += i;
230 	}
231 
232 	kfree_sensitive(tmp);
233 
234 	if (ret > 0)
235 		*ppos += ret;
236 
237 	return ret;
238 }
239 
240 /************** Raw High-Resolution Timer Entropy Data Handling **************/
241 
242 static u32 boot_raw_hires_test = 0;
243 module_param(boot_raw_hires_test, uint, 0644);
244 MODULE_PARM_DESC(boot_raw_hires_test,
245 		 "Enable gathering boot time high resolution timer entropy of the first Jitter RNG entropy events");
246 
247 static struct jent_testing jent_raw_hires = {
248 	.rb_reader = 0,
249 	.rb_writer = ATOMIC_INIT(0),
250 	.lock      = __SPIN_LOCK_UNLOCKED(jent_raw_hires.lock),
251 	.read_wait = __WAIT_QUEUE_HEAD_INITIALIZER(jent_raw_hires.read_wait)
252 };
253 
254 int jent_raw_hires_entropy_store(__u32 value)
255 {
256 	return jent_testing_store(&jent_raw_hires, value, &boot_raw_hires_test);
257 }
258 EXPORT_SYMBOL(jent_raw_hires_entropy_store);
259 
260 static int jent_raw_hires_entropy_reader(u8 *outbuf, u32 outbuflen)
261 {
262 	return jent_testing_reader(&jent_raw_hires, &boot_raw_hires_test,
263 				   outbuf, outbuflen);
264 }
265 
266 static ssize_t jent_raw_hires_read(struct file *file, char __user *to,
267 				   size_t count, loff_t *ppos)
268 {
269 	return jent_testing_extract_user(file, to, count, ppos,
270 					 jent_raw_hires_entropy_reader);
271 }
272 
273 static const struct file_operations jent_raw_hires_fops = {
274 	.owner = THIS_MODULE,
275 	.read = jent_raw_hires_read,
276 };
277 
278 /******************************* Initialization *******************************/
279 
280 void jent_testing_init(void)
281 {
282 	jent_raw_debugfs_root = debugfs_create_dir(KBUILD_MODNAME, NULL);
283 
284 	debugfs_create_file_unsafe("jent_raw_hires", 0400,
285 				   jent_raw_debugfs_root, NULL,
286 				   &jent_raw_hires_fops);
287 }
288 EXPORT_SYMBOL(jent_testing_init);
289 
290 void jent_testing_exit(void)
291 {
292 	debugfs_remove_recursive(jent_raw_debugfs_root);
293 }
294 EXPORT_SYMBOL(jent_testing_exit);
295