xref: /openbmc/linux/drivers/char/hw_random/core.c (revision c819e2cf) 
1 /*
2         Added support for the AMD Geode LX RNG
3 	(c) Copyright 2004-2005 Advanced Micro Devices, Inc.
4 
5 	derived from
6 
7  	Hardware driver for the Intel/AMD/VIA Random Number Generators (RNG)
8 	(c) Copyright 2003 Red Hat Inc <jgarzik@redhat.com>
9 
10  	derived from
11 
12         Hardware driver for the AMD 768 Random Number Generator (RNG)
13         (c) Copyright 2001 Red Hat Inc <alan@redhat.com>
14 
15  	derived from
16 
17 	Hardware driver for Intel i810 Random Number Generator (RNG)
18 	Copyright 2000,2001 Jeff Garzik <jgarzik@pobox.com>
19 	Copyright 2000,2001 Philipp Rumpf <prumpf@mandrakesoft.com>
20 
21 	Added generic RNG API
22 	Copyright 2006 Michael Buesch <m@bues.ch>
23 	Copyright 2005 (c) MontaVista Software, Inc.
24 
25 	Please read Documentation/hw_random.txt for details on use.
26 
27 	----------------------------------------------------------
28 	This software may be used and distributed according to the terms
29         of the GNU General Public License, incorporated herein by reference.
30 
31  */
32 
33 
34 #include <linux/device.h>
35 #include <linux/hw_random.h>
36 #include <linux/module.h>
37 #include <linux/kernel.h>
38 #include <linux/fs.h>
39 #include <linux/sched.h>
40 #include <linux/miscdevice.h>
41 #include <linux/kthread.h>
42 #include <linux/delay.h>
43 #include <linux/slab.h>
44 #include <linux/random.h>
45 #include <asm/uaccess.h>
46 
47 
48 #define RNG_MODULE_NAME		"hw_random"
49 #define PFX			RNG_MODULE_NAME ": "
50 #define RNG_MISCDEV_MINOR	183 /* official */
51 
52 
53 static struct hwrng *current_rng;
54 static struct task_struct *hwrng_fill;
55 static LIST_HEAD(rng_list);
56 static DEFINE_MUTEX(rng_mutex);
57 static int data_avail;
58 static u8 *rng_buffer, *rng_fillbuf;
59 static unsigned short current_quality;
60 static unsigned short default_quality; /* = 0; default to "off" */
61 
62 module_param(current_quality, ushort, 0644);
63 MODULE_PARM_DESC(current_quality,
64 		 "current hwrng entropy estimation per mill");
65 module_param(default_quality, ushort, 0644);
66 MODULE_PARM_DESC(default_quality,
67 		 "default entropy content of hwrng per mill");
68 
69 static void start_khwrngd(void);
70 
71 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
72 			       int wait);
73 
74 static size_t rng_buffer_size(void)
75 {
76 	return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
77 }
78 
79 static void add_early_randomness(struct hwrng *rng)
80 {
81 	unsigned char bytes[16];
82 	int bytes_read;
83 
84 	bytes_read = rng_get_data(rng, bytes, sizeof(bytes), 1);
85 	if (bytes_read > 0)
86 		add_device_randomness(bytes, bytes_read);
87 }
88 
89 static inline int hwrng_init(struct hwrng *rng)
90 {
91 	if (rng->init) {
92 		int ret;
93 
94 		ret =  rng->init(rng);
95 		if (ret)
96 			return ret;
97 	}
98 	add_early_randomness(rng);
99 
100 	current_quality = rng->quality ? : default_quality;
101 	current_quality &= 1023;
102 
103 	if (current_quality == 0 && hwrng_fill)
104 		kthread_stop(hwrng_fill);
105 	if (current_quality > 0 && !hwrng_fill)
106 		start_khwrngd();
107 
108 	return 0;
109 }
110 
111 static inline void hwrng_cleanup(struct hwrng *rng)
112 {
113 	if (rng && rng->cleanup)
114 		rng->cleanup(rng);
115 }
116 
117 static int rng_dev_open(struct inode *inode, struct file *filp)
118 {
119 	/* enforce read-only access to this chrdev */
120 	if ((filp->f_mode & FMODE_READ) == 0)
121 		return -EINVAL;
122 	if (filp->f_mode & FMODE_WRITE)
123 		return -EINVAL;
124 	return 0;
125 }
126 
127 static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
128 			int wait) {
129 	int present;
130 
131 	if (rng->read)
132 		return rng->read(rng, (void *)buffer, size, wait);
133 
134 	if (rng->data_present)
135 		present = rng->data_present(rng, wait);
136 	else
137 		present = 1;
138 
139 	if (present)
140 		return rng->data_read(rng, (u32 *)buffer);
141 
142 	return 0;
143 }
144 
145 static ssize_t rng_dev_read(struct file *filp, char __user *buf,
146 			    size_t size, loff_t *offp)
147 {
148 	ssize_t ret = 0;
149 	int err = 0;
150 	int bytes_read, len;
151 
152 	while (size) {
153 		if (mutex_lock_interruptible(&rng_mutex)) {
154 			err = -ERESTARTSYS;
155 			goto out;
156 		}
157 
158 		if (!current_rng) {
159 			err = -ENODEV;
160 			goto out_unlock;
161 		}
162 
163 		if (!data_avail) {
164 			bytes_read = rng_get_data(current_rng, rng_buffer,
165 				rng_buffer_size(),
166 				!(filp->f_flags & O_NONBLOCK));
167 			if (bytes_read < 0) {
168 				err = bytes_read;
169 				goto out_unlock;
170 			}
171 			data_avail = bytes_read;
172 		}
173 
174 		if (!data_avail) {
175 			if (filp->f_flags & O_NONBLOCK) {
176 				err = -EAGAIN;
177 				goto out_unlock;
178 			}
179 		} else {
180 			len = data_avail;
181 			if (len > size)
182 				len = size;
183 
184 			data_avail -= len;
185 
186 			if (copy_to_user(buf + ret, rng_buffer + data_avail,
187 								len)) {
188 				err = -EFAULT;
189 				goto out_unlock;
190 			}
191 
192 			size -= len;
193 			ret += len;
194 		}
195 
196 		mutex_unlock(&rng_mutex);
197 
198 		if (need_resched())
199 			schedule_timeout_interruptible(1);
200 
201 		if (signal_pending(current)) {
202 			err = -ERESTARTSYS;
203 			goto out;
204 		}
205 	}
206 out:
207 	return ret ? : err;
208 out_unlock:
209 	mutex_unlock(&rng_mutex);
210 	goto out;
211 }
212 
213 
214 static const struct file_operations rng_chrdev_ops = {
215 	.owner		= THIS_MODULE,
216 	.open		= rng_dev_open,
217 	.read		= rng_dev_read,
218 	.llseek		= noop_llseek,
219 };
220 
221 static struct miscdevice rng_miscdev = {
222 	.minor		= RNG_MISCDEV_MINOR,
223 	.name		= RNG_MODULE_NAME,
224 	.nodename	= "hwrng",
225 	.fops		= &rng_chrdev_ops,
226 };
227 
228 
229 static ssize_t hwrng_attr_current_store(struct device *dev,
230 					struct device_attribute *attr,
231 					const char *buf, size_t len)
232 {
233 	int err;
234 	struct hwrng *rng;
235 
236 	err = mutex_lock_interruptible(&rng_mutex);
237 	if (err)
238 		return -ERESTARTSYS;
239 	err = -ENODEV;
240 	list_for_each_entry(rng, &rng_list, list) {
241 		if (strcmp(rng->name, buf) == 0) {
242 			if (rng == current_rng) {
243 				err = 0;
244 				break;
245 			}
246 			err = hwrng_init(rng);
247 			if (err)
248 				break;
249 			hwrng_cleanup(current_rng);
250 			current_rng = rng;
251 			err = 0;
252 			break;
253 		}
254 	}
255 	mutex_unlock(&rng_mutex);
256 
257 	return err ? : len;
258 }
259 
260 static ssize_t hwrng_attr_current_show(struct device *dev,
261 				       struct device_attribute *attr,
262 				       char *buf)
263 {
264 	int err;
265 	ssize_t ret;
266 	const char *name = "none";
267 
268 	err = mutex_lock_interruptible(&rng_mutex);
269 	if (err)
270 		return -ERESTARTSYS;
271 	if (current_rng)
272 		name = current_rng->name;
273 	ret = snprintf(buf, PAGE_SIZE, "%s\n", name);
274 	mutex_unlock(&rng_mutex);
275 
276 	return ret;
277 }
278 
279 static ssize_t hwrng_attr_available_show(struct device *dev,
280 					 struct device_attribute *attr,
281 					 char *buf)
282 {
283 	int err;
284 	struct hwrng *rng;
285 
286 	err = mutex_lock_interruptible(&rng_mutex);
287 	if (err)
288 		return -ERESTARTSYS;
289 	buf[0] = '\0';
290 	list_for_each_entry(rng, &rng_list, list) {
291 		strlcat(buf, rng->name, PAGE_SIZE);
292 		strlcat(buf, " ", PAGE_SIZE);
293 	}
294 	strlcat(buf, "\n", PAGE_SIZE);
295 	mutex_unlock(&rng_mutex);
296 
297 	return strlen(buf);
298 }
299 
300 static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
301 		   hwrng_attr_current_show,
302 		   hwrng_attr_current_store);
303 static DEVICE_ATTR(rng_available, S_IRUGO,
304 		   hwrng_attr_available_show,
305 		   NULL);
306 
307 
308 static void unregister_miscdev(void)
309 {
310 	device_remove_file(rng_miscdev.this_device, &dev_attr_rng_available);
311 	device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
312 	misc_deregister(&rng_miscdev);
313 }
314 
315 static int register_miscdev(void)
316 {
317 	int err;
318 
319 	err = misc_register(&rng_miscdev);
320 	if (err)
321 		goto out;
322 	err = device_create_file(rng_miscdev.this_device,
323 				 &dev_attr_rng_current);
324 	if (err)
325 		goto err_misc_dereg;
326 	err = device_create_file(rng_miscdev.this_device,
327 				 &dev_attr_rng_available);
328 	if (err)
329 		goto err_remove_current;
330 out:
331 	return err;
332 
333 err_remove_current:
334 	device_remove_file(rng_miscdev.this_device, &dev_attr_rng_current);
335 err_misc_dereg:
336 	misc_deregister(&rng_miscdev);
337 	goto out;
338 }
339 
340 static int hwrng_fillfn(void *unused)
341 {
342 	long rc;
343 
344 	while (!kthread_should_stop()) {
345 		if (!current_rng)
346 			break;
347 		rc = rng_get_data(current_rng, rng_fillbuf,
348 				  rng_buffer_size(), 1);
349 		if (rc <= 0) {
350 			pr_warn("hwrng: no data available\n");
351 			msleep_interruptible(10000);
352 			continue;
353 		}
354 		add_hwgenerator_randomness((void *)rng_fillbuf, rc,
355 					   rc * current_quality * 8 >> 10);
356 	}
357 	hwrng_fill = NULL;
358 	return 0;
359 }
360 
361 static void start_khwrngd(void)
362 {
363 	hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng");
364 	if (hwrng_fill == ERR_PTR(-ENOMEM)) {
365 		pr_err("hwrng_fill thread creation failed");
366 		hwrng_fill = NULL;
367 	}
368 }
369 
370 int hwrng_register(struct hwrng *rng)
371 {
372 	int err = -EINVAL;
373 	struct hwrng *old_rng, *tmp;
374 
375 	if (rng->name == NULL ||
376 	    (rng->data_read == NULL && rng->read == NULL))
377 		goto out;
378 
379 	mutex_lock(&rng_mutex);
380 
381 	/* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
382 	err = -ENOMEM;
383 	if (!rng_buffer) {
384 		rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
385 		if (!rng_buffer)
386 			goto out_unlock;
387 	}
388 	if (!rng_fillbuf) {
389 		rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
390 		if (!rng_fillbuf) {
391 			kfree(rng_buffer);
392 			goto out_unlock;
393 		}
394 	}
395 
396 	/* Must not register two RNGs with the same name. */
397 	err = -EEXIST;
398 	list_for_each_entry(tmp, &rng_list, list) {
399 		if (strcmp(tmp->name, rng->name) == 0)
400 			goto out_unlock;
401 	}
402 
403 	old_rng = current_rng;
404 	if (!old_rng) {
405 		err = hwrng_init(rng);
406 		if (err)
407 			goto out_unlock;
408 		current_rng = rng;
409 	}
410 	err = 0;
411 	if (!old_rng) {
412 		err = register_miscdev();
413 		if (err) {
414 			hwrng_cleanup(rng);
415 			current_rng = NULL;
416 			goto out_unlock;
417 		}
418 	}
419 	INIT_LIST_HEAD(&rng->list);
420 	list_add_tail(&rng->list, &rng_list);
421 
422 	if (old_rng && !rng->init) {
423 		/*
424 		 * Use a new device's input to add some randomness to
425 		 * the system.  If this rng device isn't going to be
426 		 * used right away, its init function hasn't been
427 		 * called yet; so only use the randomness from devices
428 		 * that don't need an init callback.
429 		 */
430 		add_early_randomness(rng);
431 	}
432 
433 out_unlock:
434 	mutex_unlock(&rng_mutex);
435 out:
436 	return err;
437 }
438 EXPORT_SYMBOL_GPL(hwrng_register);
439 
440 void hwrng_unregister(struct hwrng *rng)
441 {
442 	int err;
443 
444 	mutex_lock(&rng_mutex);
445 
446 	list_del(&rng->list);
447 	if (current_rng == rng) {
448 		hwrng_cleanup(rng);
449 		if (list_empty(&rng_list)) {
450 			current_rng = NULL;
451 		} else {
452 			current_rng = list_entry(rng_list.prev, struct hwrng, list);
453 			err = hwrng_init(current_rng);
454 			if (err)
455 				current_rng = NULL;
456 		}
457 	}
458 	if (list_empty(&rng_list)) {
459 		unregister_miscdev();
460 		if (hwrng_fill)
461 			kthread_stop(hwrng_fill);
462 	}
463 
464 	mutex_unlock(&rng_mutex);
465 }
466 EXPORT_SYMBOL_GPL(hwrng_unregister);
467 
468 static void __exit hwrng_exit(void)
469 {
470 	mutex_lock(&rng_mutex);
471 	BUG_ON(current_rng);
472 	kfree(rng_buffer);
473 	kfree(rng_fillbuf);
474 	mutex_unlock(&rng_mutex);
475 }
476 
477 module_exit(hwrng_exit);
478 
479 MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
480 MODULE_LICENSE("GPL");
481