Branch data Line data Source code
1 : : /*
2 : : * hw_random/core.c: HWRNG core API
3 : : *
4 : : * Copyright 2006 Michael Buesch <m@bues.ch>
5 : : * Copyright 2005 (c) MontaVista Software, Inc.
6 : : *
7 : : * Please read Documentation/admin-guide/hw_random.rst for details on use.
8 : : *
9 : : * This software may be used and distributed according to the terms
10 : : * of the GNU General Public License, incorporated herein by reference.
11 : : */
12 : :
13 : : #include <linux/delay.h>
14 : : #include <linux/device.h>
15 : : #include <linux/err.h>
16 : : #include <linux/fs.h>
17 : : #include <linux/hw_random.h>
18 : : #include <linux/kernel.h>
19 : : #include <linux/kthread.h>
20 : : #include <linux/sched/signal.h>
21 : : #include <linux/miscdevice.h>
22 : : #include <linux/module.h>
23 : : #include <linux/random.h>
24 : : #include <linux/sched.h>
25 : : #include <linux/slab.h>
26 : : #include <linux/uaccess.h>
27 : :
28 : : #define RNG_MODULE_NAME "hw_random"
29 : :
30 : : static struct hwrng *current_rng;
31 : : /* the current rng has been explicitly chosen by user via sysfs */
32 : : static int cur_rng_set_by_user;
33 : : static struct task_struct *hwrng_fill;
34 : : /* list of registered rngs, sorted decending by quality */
35 : : static LIST_HEAD(rng_list);
36 : : /* Protects rng_list and current_rng */
37 : : static DEFINE_MUTEX(rng_mutex);
38 : : /* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */
39 : : static DEFINE_MUTEX(reading_mutex);
40 : : static int data_avail;
41 : : static u8 *rng_buffer, *rng_fillbuf;
42 : : static unsigned short current_quality;
43 : : static unsigned short default_quality; /* = 0; default to "off" */
44 : :
45 : : module_param(current_quality, ushort, 0644);
46 : : MODULE_PARM_DESC(current_quality,
47 : : "current hwrng entropy estimation per 1024 bits of input");
48 : : module_param(default_quality, ushort, 0644);
49 : : MODULE_PARM_DESC(default_quality,
50 : : "default entropy content of hwrng per 1024 bits of input");
51 : :
52 : : static void drop_current_rng(void);
53 : : static int hwrng_init(struct hwrng *rng);
54 : : static void start_khwrngd(void);
55 : :
56 : : static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
57 : : int wait);
58 : :
59 : : static size_t rng_buffer_size(void)
60 : : {
61 : : return SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES;
62 : : }
63 : :
64 : 3 : static void add_early_randomness(struct hwrng *rng)
65 : : {
66 : : int bytes_read;
67 : : size_t size = min_t(size_t, 16, rng_buffer_size());
68 : :
69 : 3 : mutex_lock(&reading_mutex);
70 : 3 : bytes_read = rng_get_data(rng, rng_buffer, size, 0);
71 : 3 : mutex_unlock(&reading_mutex);
72 : 3 : if (bytes_read > 0)
73 : 3 : add_device_randomness(rng_buffer, bytes_read);
74 : 3 : }
75 : :
76 : 0 : static inline void cleanup_rng(struct kref *kref)
77 : : {
78 : 0 : struct hwrng *rng = container_of(kref, struct hwrng, ref);
79 : :
80 : 0 : if (rng->cleanup)
81 : 0 : rng->cleanup(rng);
82 : :
83 : 0 : complete(&rng->cleanup_done);
84 : 0 : }
85 : :
86 : 3 : static int set_current_rng(struct hwrng *rng)
87 : : {
88 : : int err;
89 : :
90 : 3 : BUG_ON(!mutex_is_locked(&rng_mutex));
91 : :
92 : 3 : err = hwrng_init(rng);
93 : 3 : if (err)
94 : : return err;
95 : :
96 : 3 : drop_current_rng();
97 : 3 : current_rng = rng;
98 : :
99 : 3 : return 0;
100 : : }
101 : :
102 : 3 : static void drop_current_rng(void)
103 : : {
104 : 3 : BUG_ON(!mutex_is_locked(&rng_mutex));
105 : 3 : if (!current_rng)
106 : 3 : return;
107 : :
108 : : /* decrease last reference for triggering the cleanup */
109 : 0 : kref_put(¤t_rng->ref, cleanup_rng);
110 : 0 : current_rng = NULL;
111 : : }
112 : :
113 : : /* Returns ERR_PTR(), NULL or refcounted hwrng */
114 : 3 : static struct hwrng *get_current_rng(void)
115 : : {
116 : : struct hwrng *rng;
117 : :
118 : 3 : if (mutex_lock_interruptible(&rng_mutex))
119 : : return ERR_PTR(-ERESTARTSYS);
120 : :
121 : 3 : rng = current_rng;
122 : 3 : if (rng)
123 : : kref_get(&rng->ref);
124 : :
125 : 3 : mutex_unlock(&rng_mutex);
126 : 3 : return rng;
127 : : }
128 : :
129 : 3 : static void put_rng(struct hwrng *rng)
130 : : {
131 : : /*
132 : : * Hold rng_mutex here so we serialize in case they set_current_rng
133 : : * on rng again immediately.
134 : : */
135 : 3 : mutex_lock(&rng_mutex);
136 : 3 : if (rng)
137 : 3 : kref_put(&rng->ref, cleanup_rng);
138 : 3 : mutex_unlock(&rng_mutex);
139 : 3 : }
140 : :
141 : 3 : static int hwrng_init(struct hwrng *rng)
142 : : {
143 : 3 : if (kref_get_unless_zero(&rng->ref))
144 : : goto skip_init;
145 : :
146 : 3 : if (rng->init) {
147 : : int ret;
148 : :
149 : 3 : ret = rng->init(rng);
150 : 3 : if (ret)
151 : : return ret;
152 : : }
153 : :
154 : : kref_init(&rng->ref);
155 : : reinit_completion(&rng->cleanup_done);
156 : :
157 : : skip_init:
158 : 3 : add_early_randomness(rng);
159 : :
160 : 3 : current_quality = rng->quality ? : default_quality;
161 : 3 : if (current_quality > 1024)
162 : 0 : current_quality = 1024;
163 : :
164 : 3 : if (current_quality == 0 && hwrng_fill)
165 : 0 : kthread_stop(hwrng_fill);
166 : 3 : if (current_quality > 0 && !hwrng_fill)
167 : 0 : start_khwrngd();
168 : :
169 : : return 0;
170 : : }
171 : :
172 : 3 : static int rng_dev_open(struct inode *inode, struct file *filp)
173 : : {
174 : : /* enforce read-only access to this chrdev */
175 : 3 : if ((filp->f_mode & FMODE_READ) == 0)
176 : : return -EINVAL;
177 : 3 : if (filp->f_mode & FMODE_WRITE)
178 : : return -EINVAL;
179 : 3 : return 0;
180 : : }
181 : :
182 : 3 : static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size,
183 : : int wait) {
184 : : int present;
185 : :
186 : 3 : BUG_ON(!mutex_is_locked(&reading_mutex));
187 : 3 : if (rng->read)
188 : 3 : return rng->read(rng, (void *)buffer, size, wait);
189 : :
190 : 0 : if (rng->data_present)
191 : 0 : present = rng->data_present(rng, wait);
192 : : else
193 : : present = 1;
194 : :
195 : 0 : if (present)
196 : 0 : return rng->data_read(rng, (u32 *)buffer);
197 : :
198 : : return 0;
199 : : }
200 : :
201 : 3 : static ssize_t rng_dev_read(struct file *filp, char __user *buf,
202 : : size_t size, loff_t *offp)
203 : : {
204 : : ssize_t ret = 0;
205 : : int err = 0;
206 : : int bytes_read, len;
207 : : struct hwrng *rng;
208 : :
209 : 3 : while (size) {
210 : 3 : rng = get_current_rng();
211 : 3 : if (IS_ERR(rng)) {
212 : : err = PTR_ERR(rng);
213 : 0 : goto out;
214 : : }
215 : 3 : if (!rng) {
216 : : err = -ENODEV;
217 : : goto out;
218 : : }
219 : :
220 : 3 : if (mutex_lock_interruptible(&reading_mutex)) {
221 : : err = -ERESTARTSYS;
222 : : goto out_put;
223 : : }
224 : 3 : if (!data_avail) {
225 : 3 : bytes_read = rng_get_data(rng, rng_buffer,
226 : : rng_buffer_size(),
227 : 3 : !(filp->f_flags & O_NONBLOCK));
228 : 3 : if (bytes_read < 0) {
229 : 0 : err = bytes_read;
230 : 0 : goto out_unlock_reading;
231 : : }
232 : 3 : data_avail = bytes_read;
233 : : }
234 : :
235 : 3 : if (!data_avail) {
236 : 0 : if (filp->f_flags & O_NONBLOCK) {
237 : : err = -EAGAIN;
238 : : goto out_unlock_reading;
239 : : }
240 : : } else {
241 : : len = data_avail;
242 : 3 : if (len > size)
243 : 2 : len = size;
244 : :
245 : 3 : data_avail -= len;
246 : :
247 : 3 : if (copy_to_user(buf + ret, rng_buffer + data_avail,
248 : : len)) {
249 : : err = -EFAULT;
250 : : goto out_unlock_reading;
251 : : }
252 : :
253 : 3 : size -= len;
254 : 3 : ret += len;
255 : : }
256 : :
257 : 3 : mutex_unlock(&reading_mutex);
258 : 3 : put_rng(rng);
259 : :
260 : 3 : if (need_resched())
261 : 3 : schedule_timeout_interruptible(1);
262 : :
263 : 3 : if (signal_pending(current)) {
264 : : err = -ERESTARTSYS;
265 : : goto out;
266 : : }
267 : : }
268 : : out:
269 : 3 : return ret ? : err;
270 : :
271 : : out_unlock_reading:
272 : 0 : mutex_unlock(&reading_mutex);
273 : : out_put:
274 : 0 : put_rng(rng);
275 : 0 : goto out;
276 : : }
277 : :
278 : : static const struct file_operations rng_chrdev_ops = {
279 : : .owner = THIS_MODULE,
280 : : .open = rng_dev_open,
281 : : .read = rng_dev_read,
282 : : .llseek = noop_llseek,
283 : : };
284 : :
285 : : static const struct attribute_group *rng_dev_groups[];
286 : :
287 : : static struct miscdevice rng_miscdev = {
288 : : .minor = HWRNG_MINOR,
289 : : .name = RNG_MODULE_NAME,
290 : : .nodename = "hwrng",
291 : : .fops = &rng_chrdev_ops,
292 : : .groups = rng_dev_groups,
293 : : };
294 : :
295 : 0 : static int enable_best_rng(void)
296 : : {
297 : : int ret = -ENODEV;
298 : :
299 : 0 : BUG_ON(!mutex_is_locked(&rng_mutex));
300 : :
301 : : /* rng_list is sorted by quality, use the best (=first) one */
302 : 0 : if (!list_empty(&rng_list)) {
303 : : struct hwrng *new_rng;
304 : :
305 : 0 : new_rng = list_entry(rng_list.next, struct hwrng, list);
306 : 0 : ret = ((new_rng == current_rng) ? 0 : set_current_rng(new_rng));
307 : 0 : if (!ret)
308 : 0 : cur_rng_set_by_user = 0;
309 : : } else {
310 : 0 : drop_current_rng();
311 : 0 : cur_rng_set_by_user = 0;
312 : : ret = 0;
313 : : }
314 : :
315 : 0 : return ret;
316 : : }
317 : :
318 : 0 : static ssize_t hwrng_attr_current_store(struct device *dev,
319 : : struct device_attribute *attr,
320 : : const char *buf, size_t len)
321 : : {
322 : : int err = -ENODEV;
323 : : struct hwrng *rng;
324 : :
325 : 0 : err = mutex_lock_interruptible(&rng_mutex);
326 : 0 : if (err)
327 : : return -ERESTARTSYS;
328 : :
329 : 0 : if (sysfs_streq(buf, "")) {
330 : 0 : err = enable_best_rng();
331 : : } else {
332 : 0 : list_for_each_entry(rng, &rng_list, list) {
333 : 0 : if (sysfs_streq(rng->name, buf)) {
334 : 0 : cur_rng_set_by_user = 1;
335 : 0 : err = set_current_rng(rng);
336 : 0 : break;
337 : : }
338 : : }
339 : : }
340 : :
341 : 0 : mutex_unlock(&rng_mutex);
342 : :
343 : 0 : return err ? : len;
344 : : }
345 : :
346 : 0 : static ssize_t hwrng_attr_current_show(struct device *dev,
347 : : struct device_attribute *attr,
348 : : char *buf)
349 : : {
350 : : ssize_t ret;
351 : : struct hwrng *rng;
352 : :
353 : 0 : rng = get_current_rng();
354 : 0 : if (IS_ERR(rng))
355 : 0 : return PTR_ERR(rng);
356 : :
357 : 0 : ret = snprintf(buf, PAGE_SIZE, "%s\n", rng ? rng->name : "none");
358 : 0 : put_rng(rng);
359 : :
360 : 0 : return ret;
361 : : }
362 : :
363 : 0 : static ssize_t hwrng_attr_available_show(struct device *dev,
364 : : struct device_attribute *attr,
365 : : char *buf)
366 : : {
367 : : int err;
368 : : struct hwrng *rng;
369 : :
370 : 0 : err = mutex_lock_interruptible(&rng_mutex);
371 : 0 : if (err)
372 : : return -ERESTARTSYS;
373 : 0 : buf[0] = '\0';
374 : 0 : list_for_each_entry(rng, &rng_list, list) {
375 : 0 : strlcat(buf, rng->name, PAGE_SIZE);
376 : 0 : strlcat(buf, " ", PAGE_SIZE);
377 : : }
378 : 0 : strlcat(buf, "\n", PAGE_SIZE);
379 : 0 : mutex_unlock(&rng_mutex);
380 : :
381 : 0 : return strlen(buf);
382 : : }
383 : :
384 : 0 : static ssize_t hwrng_attr_selected_show(struct device *dev,
385 : : struct device_attribute *attr,
386 : : char *buf)
387 : : {
388 : 0 : return snprintf(buf, PAGE_SIZE, "%d\n", cur_rng_set_by_user);
389 : : }
390 : :
391 : : static DEVICE_ATTR(rng_current, S_IRUGO | S_IWUSR,
392 : : hwrng_attr_current_show,
393 : : hwrng_attr_current_store);
394 : : static DEVICE_ATTR(rng_available, S_IRUGO,
395 : : hwrng_attr_available_show,
396 : : NULL);
397 : : static DEVICE_ATTR(rng_selected, S_IRUGO,
398 : : hwrng_attr_selected_show,
399 : : NULL);
400 : :
401 : : static struct attribute *rng_dev_attrs[] = {
402 : : &dev_attr_rng_current.attr,
403 : : &dev_attr_rng_available.attr,
404 : : &dev_attr_rng_selected.attr,
405 : : NULL
406 : : };
407 : :
408 : : ATTRIBUTE_GROUPS(rng_dev);
409 : :
410 : 0 : static void __exit unregister_miscdev(void)
411 : : {
412 : 0 : misc_deregister(&rng_miscdev);
413 : 0 : }
414 : :
415 : 3 : static int __init register_miscdev(void)
416 : : {
417 : 3 : return misc_register(&rng_miscdev);
418 : : }
419 : :
420 : 0 : static int hwrng_fillfn(void *unused)
421 : : {
422 : : long rc;
423 : :
424 : 0 : while (!kthread_should_stop()) {
425 : : struct hwrng *rng;
426 : :
427 : 0 : rng = get_current_rng();
428 : 0 : if (IS_ERR(rng) || !rng)
429 : : break;
430 : 0 : mutex_lock(&reading_mutex);
431 : 0 : rc = rng_get_data(rng, rng_fillbuf,
432 : : rng_buffer_size(), 1);
433 : 0 : mutex_unlock(&reading_mutex);
434 : 0 : put_rng(rng);
435 : 0 : if (rc <= 0) {
436 : 0 : pr_warn("hwrng: no data available\n");
437 : 0 : msleep_interruptible(10000);
438 : 0 : continue;
439 : : }
440 : : /* Outside lock, sure, but y'know: randomness. */
441 : 0 : add_hwgenerator_randomness((void *)rng_fillbuf, rc,
442 : 0 : rc * current_quality * 8 >> 10);
443 : : }
444 : 0 : hwrng_fill = NULL;
445 : 0 : return 0;
446 : : }
447 : :
448 : 0 : static void start_khwrngd(void)
449 : : {
450 : 0 : hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng");
451 : 0 : if (IS_ERR(hwrng_fill)) {
452 : 0 : pr_err("hwrng_fill thread creation failed\n");
453 : 0 : hwrng_fill = NULL;
454 : : }
455 : 0 : }
456 : :
457 : 3 : int hwrng_register(struct hwrng *rng)
458 : : {
459 : : int err = -EINVAL;
460 : : struct hwrng *old_rng, *tmp;
461 : : struct list_head *rng_list_ptr;
462 : :
463 : 3 : if (!rng->name || (!rng->data_read && !rng->read))
464 : : goto out;
465 : :
466 : 3 : mutex_lock(&rng_mutex);
467 : : /* Must not register two RNGs with the same name. */
468 : : err = -EEXIST;
469 : 3 : list_for_each_entry(tmp, &rng_list, list) {
470 : 0 : if (strcmp(tmp->name, rng->name) == 0)
471 : : goto out_unlock;
472 : : }
473 : :
474 : : init_completion(&rng->cleanup_done);
475 : 3 : complete(&rng->cleanup_done);
476 : :
477 : : /* rng_list is sorted by decreasing quality */
478 : 3 : list_for_each(rng_list_ptr, &rng_list) {
479 : : tmp = list_entry(rng_list_ptr, struct hwrng, list);
480 : 0 : if (tmp->quality < rng->quality)
481 : : break;
482 : : }
483 : 3 : list_add_tail(&rng->list, rng_list_ptr);
484 : :
485 : 3 : old_rng = current_rng;
486 : : err = 0;
487 : 3 : if (!old_rng ||
488 : 0 : (!cur_rng_set_by_user && rng->quality > old_rng->quality)) {
489 : : /*
490 : : * Set new rng as current as the new rng source
491 : : * provides better entropy quality and was not
492 : : * chosen by userspace.
493 : : */
494 : 3 : err = set_current_rng(rng);
495 : 3 : if (err)
496 : : goto out_unlock;
497 : : }
498 : :
499 : 3 : if (old_rng && !rng->init) {
500 : : /*
501 : : * Use a new device's input to add some randomness to
502 : : * the system. If this rng device isn't going to be
503 : : * used right away, its init function hasn't been
504 : : * called yet; so only use the randomness from devices
505 : : * that don't need an init callback.
506 : : */
507 : 0 : add_early_randomness(rng);
508 : : }
509 : :
510 : : out_unlock:
511 : 3 : mutex_unlock(&rng_mutex);
512 : : out:
513 : 3 : return err;
514 : : }
515 : : EXPORT_SYMBOL_GPL(hwrng_register);
516 : :
517 : 0 : void hwrng_unregister(struct hwrng *rng)
518 : : {
519 : : int err;
520 : :
521 : 0 : mutex_lock(&rng_mutex);
522 : :
523 : : list_del(&rng->list);
524 : 0 : if (current_rng == rng) {
525 : 0 : err = enable_best_rng();
526 : 0 : if (err) {
527 : 0 : drop_current_rng();
528 : 0 : cur_rng_set_by_user = 0;
529 : : }
530 : : }
531 : :
532 : 0 : if (list_empty(&rng_list)) {
533 : 0 : mutex_unlock(&rng_mutex);
534 : 0 : if (hwrng_fill)
535 : 0 : kthread_stop(hwrng_fill);
536 : : } else
537 : 0 : mutex_unlock(&rng_mutex);
538 : :
539 : 0 : wait_for_completion(&rng->cleanup_done);
540 : 0 : }
541 : : EXPORT_SYMBOL_GPL(hwrng_unregister);
542 : :
543 : 0 : static void devm_hwrng_release(struct device *dev, void *res)
544 : : {
545 : 0 : hwrng_unregister(*(struct hwrng **)res);
546 : 0 : }
547 : :
548 : 0 : static int devm_hwrng_match(struct device *dev, void *res, void *data)
549 : : {
550 : : struct hwrng **r = res;
551 : :
552 : 0 : if (WARN_ON(!r || !*r))
553 : : return 0;
554 : :
555 : 0 : return *r == data;
556 : : }
557 : :
558 : 3 : int devm_hwrng_register(struct device *dev, struct hwrng *rng)
559 : : {
560 : : struct hwrng **ptr;
561 : : int error;
562 : :
563 : : ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL);
564 : 3 : if (!ptr)
565 : : return -ENOMEM;
566 : :
567 : 3 : error = hwrng_register(rng);
568 : 3 : if (error) {
569 : 0 : devres_free(ptr);
570 : 0 : return error;
571 : : }
572 : :
573 : 3 : *ptr = rng;
574 : 3 : devres_add(dev, ptr);
575 : 3 : return 0;
576 : : }
577 : : EXPORT_SYMBOL_GPL(devm_hwrng_register);
578 : :
579 : 0 : void devm_hwrng_unregister(struct device *dev, struct hwrng *rng)
580 : : {
581 : 0 : devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng);
582 : 0 : }
583 : : EXPORT_SYMBOL_GPL(devm_hwrng_unregister);
584 : :
585 : 3 : static int __init hwrng_modinit(void)
586 : : {
587 : : int ret = -ENOMEM;
588 : :
589 : : /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */
590 : 3 : rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL);
591 : 3 : if (!rng_buffer)
592 : : return -ENOMEM;
593 : :
594 : 3 : rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL);
595 : 3 : if (!rng_fillbuf) {
596 : 0 : kfree(rng_buffer);
597 : 0 : return -ENOMEM;
598 : : }
599 : :
600 : 3 : ret = register_miscdev();
601 : 3 : if (ret) {
602 : 0 : kfree(rng_fillbuf);
603 : 0 : kfree(rng_buffer);
604 : : }
605 : :
606 : 3 : return ret;
607 : : }
608 : :
609 : 0 : static void __exit hwrng_modexit(void)
610 : : {
611 : 0 : mutex_lock(&rng_mutex);
612 : 0 : BUG_ON(current_rng);
613 : 0 : kfree(rng_buffer);
614 : 0 : kfree(rng_fillbuf);
615 : 0 : mutex_unlock(&rng_mutex);
616 : :
617 : 0 : unregister_miscdev();
618 : 0 : }
619 : :
620 : : module_init(hwrng_modinit);
621 : : module_exit(hwrng_modexit);
622 : :
623 : : MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver");
624 : : MODULE_LICENSE("GPL");
|
