Commit | Line | Data |
---|---|---|
844dd05f | 1 | /* |
dd801483 CL |
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 | * | |
4f4cfa6c | 7 | * Please read Documentation/admin-guide/hw_random.rst for details on use. |
dd801483 CL |
8 | * |
9 | * This software may be used and distributed according to the terms | |
10 | * of the GNU General Public License, incorporated herein by reference. | |
844dd05f MB |
11 | */ |
12 | ||
affdec58 | 13 | #include <linux/delay.h> |
844dd05f | 14 | #include <linux/device.h> |
affdec58 CL |
15 | #include <linux/err.h> |
16 | #include <linux/fs.h> | |
844dd05f | 17 | #include <linux/hw_random.h> |
844dd05f | 18 | #include <linux/kernel.h> |
be4000bc | 19 | #include <linux/kthread.h> |
affdec58 CL |
20 | #include <linux/miscdevice.h> |
21 | #include <linux/module.h> | |
d9e79726 | 22 | #include <linux/random.h> |
affdec58 | 23 | #include <linux/sched.h> |
d88bdbd9 | 24 | #include <linux/sched/signal.h> |
affdec58 | 25 | #include <linux/slab.h> |
78aafb38 | 26 | #include <linux/string.h> |
7c0f6ba6 | 27 | #include <linux/uaccess.h> |
844dd05f | 28 | |
844dd05f | 29 | #define RNG_MODULE_NAME "hw_random" |
844dd05f | 30 | |
78aafb38 HX |
31 | #define RNG_BUFFER_SIZE (SMP_CACHE_BYTES < 32 ? 32 : SMP_CACHE_BYTES) |
32 | ||
844dd05f | 33 | static struct hwrng *current_rng; |
10a515dd HF |
34 | /* the current rng has been explicitly chosen by user via sysfs */ |
35 | static int cur_rng_set_by_user; | |
be4000bc | 36 | static struct task_struct *hwrng_fill; |
c90e4539 | 37 | /* list of registered rngs */ |
844dd05f | 38 | static LIST_HEAD(rng_list); |
9372b35e | 39 | /* Protects rng_list and current_rng */ |
844dd05f | 40 | static DEFINE_MUTEX(rng_mutex); |
9372b35e RR |
41 | /* Protects rng read functions, data_avail, rng_buffer and rng_fillbuf */ |
42 | static DEFINE_MUTEX(reading_mutex); | |
9996508b | 43 | static int data_avail; |
be4000bc | 44 | static u8 *rng_buffer, *rng_fillbuf; |
0f734e6e | 45 | static unsigned short current_quality; |
16bdbae3 | 46 | static unsigned short default_quality = 1024; /* default to maximum */ |
be4000bc TD |
47 | |
48 | module_param(current_quality, ushort, 0644); | |
49 | MODULE_PARM_DESC(current_quality, | |
82082856 | 50 | "current hwrng entropy estimation per 1024 bits of input -- obsolete, use rng_quality instead"); |
0f734e6e TD |
51 | module_param(default_quality, ushort, 0644); |
52 | MODULE_PARM_DESC(default_quality, | |
16bdbae3 | 53 | "default maximum entropy content of hwrng per 1024 bits of input"); |
be4000bc | 54 | |
ff77c150 | 55 | static void drop_current_rng(void); |
90ac41bd | 56 | static int hwrng_init(struct hwrng *rng); |
b006c439 | 57 | static int hwrng_fillfn(void *unused); |
f7f154f1 | 58 | |
d3cc7996 AS |
59 | static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size, |
60 | int wait); | |
61 | ||
f7f154f1 RR |
62 | static size_t rng_buffer_size(void) |
63 | { | |
78aafb38 | 64 | return RNG_BUFFER_SIZE; |
f7f154f1 | 65 | } |
844dd05f | 66 | |
3a2c0ba5 RR |
67 | static inline void cleanup_rng(struct kref *kref) |
68 | { | |
69 | struct hwrng *rng = container_of(kref, struct hwrng, ref); | |
70 | ||
71 | if (rng->cleanup) | |
72 | rng->cleanup(rng); | |
a027f30d | 73 | |
77584ee5 | 74 | complete(&rng->cleanup_done); |
3a2c0ba5 RR |
75 | } |
76 | ||
90ac41bd | 77 | static int set_current_rng(struct hwrng *rng) |
3a2c0ba5 | 78 | { |
90ac41bd HX |
79 | int err; |
80 | ||
3a2c0ba5 | 81 | BUG_ON(!mutex_is_locked(&rng_mutex)); |
90ac41bd HX |
82 | |
83 | err = hwrng_init(rng); | |
84 | if (err) | |
85 | return err; | |
86 | ||
ff77c150 | 87 | drop_current_rng(); |
3a2c0ba5 | 88 | current_rng = rng; |
90ac41bd | 89 | |
b006c439 DB |
90 | /* if necessary, start hwrng thread */ |
91 | if (!hwrng_fill) { | |
92 | hwrng_fill = kthread_run(hwrng_fillfn, NULL, "hwrng"); | |
93 | if (IS_ERR(hwrng_fill)) { | |
94 | pr_err("hwrng_fill thread creation failed\n"); | |
95 | hwrng_fill = NULL; | |
96 | } | |
97 | } | |
98 | ||
90ac41bd | 99 | return 0; |
3a2c0ba5 RR |
100 | } |
101 | ||
102 | static void drop_current_rng(void) | |
103 | { | |
104 | BUG_ON(!mutex_is_locked(&rng_mutex)); | |
105 | if (!current_rng) | |
106 | return; | |
107 | ||
108 | /* decrease last reference for triggering the cleanup */ | |
109 | kref_put(¤t_rng->ref, cleanup_rng); | |
110 | current_rng = NULL; | |
111 | } | |
112 | ||
113 | /* Returns ERR_PTR(), NULL or refcounted hwrng */ | |
daae28de LV |
114 | static struct hwrng *get_current_rng_nolock(void) |
115 | { | |
116 | if (current_rng) | |
117 | kref_get(¤t_rng->ref); | |
118 | ||
119 | return current_rng; | |
120 | } | |
121 | ||
3a2c0ba5 RR |
122 | static struct hwrng *get_current_rng(void) |
123 | { | |
124 | struct hwrng *rng; | |
125 | ||
126 | if (mutex_lock_interruptible(&rng_mutex)) | |
127 | return ERR_PTR(-ERESTARTSYS); | |
128 | ||
daae28de | 129 | rng = get_current_rng_nolock(); |
3a2c0ba5 RR |
130 | |
131 | mutex_unlock(&rng_mutex); | |
132 | return rng; | |
133 | } | |
134 | ||
135 | static void put_rng(struct hwrng *rng) | |
136 | { | |
137 | /* | |
138 | * Hold rng_mutex here so we serialize in case they set_current_rng | |
139 | * on rng again immediately. | |
140 | */ | |
141 | mutex_lock(&rng_mutex); | |
142 | if (rng) | |
143 | kref_put(&rng->ref, cleanup_rng); | |
144 | mutex_unlock(&rng_mutex); | |
145 | } | |
146 | ||
90ac41bd | 147 | static int hwrng_init(struct hwrng *rng) |
844dd05f | 148 | { |
15b66cd5 HX |
149 | if (kref_get_unless_zero(&rng->ref)) |
150 | goto skip_init; | |
151 | ||
d3cc7996 AS |
152 | if (rng->init) { |
153 | int ret; | |
154 | ||
155 | ret = rng->init(rng); | |
156 | if (ret) | |
157 | return ret; | |
158 | } | |
15b66cd5 HX |
159 | |
160 | kref_init(&rng->ref); | |
161 | reinit_completion(&rng->cleanup_done); | |
162 | ||
163 | skip_init: | |
16bdbae3 | 164 | rng->quality = min_t(u16, min_t(u16, default_quality, 1024), rng->quality ?: 1024); |
f0fb6953 | 165 | current_quality = rng->quality; /* obsolete */ |
0f734e6e | 166 | |
d3cc7996 | 167 | return 0; |
844dd05f MB |
168 | } |
169 | ||
844dd05f MB |
170 | static int rng_dev_open(struct inode *inode, struct file *filp) |
171 | { | |
172 | /* enforce read-only access to this chrdev */ | |
173 | if ((filp->f_mode & FMODE_READ) == 0) | |
174 | return -EINVAL; | |
175 | if (filp->f_mode & FMODE_WRITE) | |
176 | return -EINVAL; | |
177 | return 0; | |
178 | } | |
179 | ||
9996508b IM |
180 | static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size, |
181 | int wait) { | |
182 | int present; | |
183 | ||
9372b35e | 184 | BUG_ON(!mutex_is_locked(&reading_mutex)); |
9996508b IM |
185 | if (rng->read) |
186 | return rng->read(rng, (void *)buffer, size, wait); | |
187 | ||
188 | if (rng->data_present) | |
189 | present = rng->data_present(rng, wait); | |
190 | else | |
191 | present = 1; | |
192 | ||
193 | if (present) | |
194 | return rng->data_read(rng, (u32 *)buffer); | |
195 | ||
196 | return 0; | |
197 | } | |
198 | ||
844dd05f MB |
199 | static ssize_t rng_dev_read(struct file *filp, char __user *buf, |
200 | size_t size, loff_t *offp) | |
201 | { | |
78aafb38 | 202 | u8 buffer[RNG_BUFFER_SIZE]; |
844dd05f | 203 | ssize_t ret = 0; |
984e976f | 204 | int err = 0; |
9996508b | 205 | int bytes_read, len; |
3a2c0ba5 | 206 | struct hwrng *rng; |
844dd05f MB |
207 | |
208 | while (size) { | |
3a2c0ba5 RR |
209 | rng = get_current_rng(); |
210 | if (IS_ERR(rng)) { | |
211 | err = PTR_ERR(rng); | |
844dd05f | 212 | goto out; |
9996508b | 213 | } |
3a2c0ba5 | 214 | if (!rng) { |
844dd05f | 215 | err = -ENODEV; |
3a2c0ba5 | 216 | goto out; |
844dd05f | 217 | } |
984e976f | 218 | |
1ab87298 JS |
219 | if (mutex_lock_interruptible(&reading_mutex)) { |
220 | err = -ERESTARTSYS; | |
221 | goto out_put; | |
222 | } | |
9996508b | 223 | if (!data_avail) { |
3a2c0ba5 | 224 | bytes_read = rng_get_data(rng, rng_buffer, |
f7f154f1 | 225 | rng_buffer_size(), |
9996508b IM |
226 | !(filp->f_flags & O_NONBLOCK)); |
227 | if (bytes_read < 0) { | |
228 | err = bytes_read; | |
9372b35e | 229 | goto out_unlock_reading; |
78aafb38 HX |
230 | } else if (bytes_read == 0 && |
231 | (filp->f_flags & O_NONBLOCK)) { | |
232 | err = -EAGAIN; | |
233 | goto out_unlock_reading; | |
9996508b | 234 | } |
78aafb38 | 235 | |
9996508b | 236 | data_avail = bytes_read; |
893f1128 | 237 | } |
844dd05f | 238 | |
78aafb38 HX |
239 | len = data_avail; |
240 | if (len) { | |
9996508b IM |
241 | if (len > size) |
242 | len = size; | |
243 | ||
244 | data_avail -= len; | |
245 | ||
78aafb38 HX |
246 | memcpy(buffer, rng_buffer + data_avail, len); |
247 | } | |
248 | mutex_unlock(&reading_mutex); | |
249 | put_rng(rng); | |
250 | ||
251 | if (len) { | |
252 | if (copy_to_user(buf + ret, buffer, len)) { | |
9996508b | 253 | err = -EFAULT; |
78aafb38 | 254 | goto out; |
9996508b IM |
255 | } |
256 | ||
257 | size -= len; | |
258 | ret += len; | |
844dd05f MB |
259 | } |
260 | ||
9996508b | 261 | |
844dd05f MB |
262 | if (need_resched()) |
263 | schedule_timeout_interruptible(1); | |
9996508b IM |
264 | |
265 | if (signal_pending(current)) { | |
266 | err = -ERESTARTSYS; | |
844dd05f | 267 | goto out; |
9996508b | 268 | } |
844dd05f MB |
269 | } |
270 | out: | |
78aafb38 | 271 | memzero_explicit(buffer, sizeof(buffer)); |
844dd05f | 272 | return ret ? : err; |
3a2c0ba5 | 273 | |
9372b35e RR |
274 | out_unlock_reading: |
275 | mutex_unlock(&reading_mutex); | |
1ab87298 | 276 | out_put: |
3a2c0ba5 RR |
277 | put_rng(rng); |
278 | goto out; | |
844dd05f MB |
279 | } |
280 | ||
62322d25 | 281 | static const struct file_operations rng_chrdev_ops = { |
844dd05f MB |
282 | .owner = THIS_MODULE, |
283 | .open = rng_dev_open, | |
284 | .read = rng_dev_read, | |
6038f373 | 285 | .llseek = noop_llseek, |
844dd05f MB |
286 | }; |
287 | ||
0daa7a0a TI |
288 | static const struct attribute_group *rng_dev_groups[]; |
289 | ||
844dd05f | 290 | static struct miscdevice rng_miscdev = { |
fd50d71f | 291 | .minor = HWRNG_MINOR, |
844dd05f | 292 | .name = RNG_MODULE_NAME, |
e454cea2 | 293 | .nodename = "hwrng", |
844dd05f | 294 | .fops = &rng_chrdev_ops, |
0daa7a0a | 295 | .groups = rng_dev_groups, |
844dd05f MB |
296 | }; |
297 | ||
142a27f0 PM |
298 | static int enable_best_rng(void) |
299 | { | |
c90e4539 | 300 | struct hwrng *rng, *new_rng = NULL; |
142a27f0 PM |
301 | int ret = -ENODEV; |
302 | ||
303 | BUG_ON(!mutex_is_locked(&rng_mutex)); | |
304 | ||
c90e4539 DB |
305 | /* no rng to use? */ |
306 | if (list_empty(&rng_list)) { | |
0e4b5294 GH |
307 | drop_current_rng(); |
308 | cur_rng_set_by_user = 0; | |
c90e4539 DB |
309 | return 0; |
310 | } | |
311 | ||
312 | /* use the rng which offers the best quality */ | |
313 | list_for_each_entry(rng, &rng_list, list) { | |
314 | if (!new_rng || rng->quality > new_rng->quality) | |
315 | new_rng = rng; | |
142a27f0 PM |
316 | } |
317 | ||
c90e4539 DB |
318 | ret = ((new_rng == current_rng) ? 0 : set_current_rng(new_rng)); |
319 | if (!ret) | |
320 | cur_rng_set_by_user = 0; | |
321 | ||
142a27f0 PM |
322 | return ret; |
323 | } | |
324 | ||
98f481f2 Y |
325 | static ssize_t rng_current_store(struct device *dev, |
326 | struct device_attribute *attr, | |
327 | const char *buf, size_t len) | |
844dd05f | 328 | { |
cb028f16 | 329 | int err; |
67ec8cdf | 330 | struct hwrng *rng, *new_rng; |
844dd05f MB |
331 | |
332 | err = mutex_lock_interruptible(&rng_mutex); | |
333 | if (err) | |
334 | return -ERESTARTSYS; | |
142a27f0 PM |
335 | |
336 | if (sysfs_streq(buf, "")) { | |
337 | err = enable_best_rng(); | |
338 | } else { | |
339 | list_for_each_entry(rng, &rng_list, list) { | |
340 | if (sysfs_streq(rng->name, buf)) { | |
90ac41bd | 341 | err = set_current_rng(rng); |
f41aa47c DB |
342 | if (!err) |
343 | cur_rng_set_by_user = 1; | |
142a27f0 PM |
344 | break; |
345 | } | |
844dd05f MB |
346 | } |
347 | } | |
daae28de | 348 | new_rng = get_current_rng_nolock(); |
844dd05f MB |
349 | mutex_unlock(&rng_mutex); |
350 | ||
67ec8cdf | 351 | if (new_rng) |
daae28de | 352 | put_rng(new_rng); |
daae28de | 353 | |
844dd05f MB |
354 | return err ? : len; |
355 | } | |
356 | ||
98f481f2 Y |
357 | static ssize_t rng_current_show(struct device *dev, |
358 | struct device_attribute *attr, | |
359 | char *buf) | |
844dd05f | 360 | { |
844dd05f | 361 | ssize_t ret; |
3a2c0ba5 | 362 | struct hwrng *rng; |
844dd05f | 363 | |
3a2c0ba5 RR |
364 | rng = get_current_rng(); |
365 | if (IS_ERR(rng)) | |
366 | return PTR_ERR(rng); | |
367 | ||
90d012fb | 368 | ret = sysfs_emit(buf, "%s\n", rng ? rng->name : "none"); |
3a2c0ba5 | 369 | put_rng(rng); |
844dd05f MB |
370 | |
371 | return ret; | |
372 | } | |
373 | ||
98f481f2 Y |
374 | static ssize_t rng_available_show(struct device *dev, |
375 | struct device_attribute *attr, | |
376 | char *buf) | |
844dd05f MB |
377 | { |
378 | int err; | |
844dd05f MB |
379 | struct hwrng *rng; |
380 | ||
381 | err = mutex_lock_interruptible(&rng_mutex); | |
382 | if (err) | |
383 | return -ERESTARTSYS; | |
384 | buf[0] = '\0'; | |
385 | list_for_each_entry(rng, &rng_list, list) { | |
61daf055 RS |
386 | strlcat(buf, rng->name, PAGE_SIZE); |
387 | strlcat(buf, " ", PAGE_SIZE); | |
844dd05f | 388 | } |
61daf055 | 389 | strlcat(buf, "\n", PAGE_SIZE); |
844dd05f MB |
390 | mutex_unlock(&rng_mutex); |
391 | ||
61daf055 | 392 | return strlen(buf); |
844dd05f MB |
393 | } |
394 | ||
98f481f2 Y |
395 | static ssize_t rng_selected_show(struct device *dev, |
396 | struct device_attribute *attr, | |
397 | char *buf) | |
10a515dd | 398 | { |
91253022 | 399 | return sysfs_emit(buf, "%d\n", cur_rng_set_by_user); |
10a515dd HF |
400 | } |
401 | ||
82082856 DB |
402 | static ssize_t rng_quality_show(struct device *dev, |
403 | struct device_attribute *attr, | |
404 | char *buf) | |
405 | { | |
406 | ssize_t ret; | |
407 | struct hwrng *rng; | |
408 | ||
409 | rng = get_current_rng(); | |
410 | if (IS_ERR(rng)) | |
411 | return PTR_ERR(rng); | |
412 | ||
413 | if (!rng) /* no need to put_rng */ | |
414 | return -ENODEV; | |
415 | ||
416 | ret = sysfs_emit(buf, "%hu\n", rng->quality); | |
417 | put_rng(rng); | |
418 | ||
419 | return ret; | |
420 | } | |
421 | ||
422 | static ssize_t rng_quality_store(struct device *dev, | |
423 | struct device_attribute *attr, | |
424 | const char *buf, size_t len) | |
425 | { | |
426 | u16 quality; | |
427 | int ret = -EINVAL; | |
428 | ||
429 | if (len < 2) | |
430 | return -EINVAL; | |
431 | ||
432 | ret = mutex_lock_interruptible(&rng_mutex); | |
433 | if (ret) | |
434 | return -ERESTARTSYS; | |
435 | ||
436 | ret = kstrtou16(buf, 0, &quality); | |
437 | if (ret || quality > 1024) { | |
438 | ret = -EINVAL; | |
439 | goto out; | |
440 | } | |
441 | ||
442 | if (!current_rng) { | |
443 | ret = -ENODEV; | |
444 | goto out; | |
445 | } | |
446 | ||
447 | current_rng->quality = quality; | |
448 | current_quality = quality; /* obsolete */ | |
449 | ||
450 | /* the best available RNG may have changed */ | |
451 | ret = enable_best_rng(); | |
452 | ||
82082856 DB |
453 | out: |
454 | mutex_unlock(&rng_mutex); | |
455 | return ret ? ret : len; | |
456 | } | |
457 | ||
98f481f2 Y |
458 | static DEVICE_ATTR_RW(rng_current); |
459 | static DEVICE_ATTR_RO(rng_available); | |
460 | static DEVICE_ATTR_RO(rng_selected); | |
82082856 | 461 | static DEVICE_ATTR_RW(rng_quality); |
844dd05f | 462 | |
0daa7a0a TI |
463 | static struct attribute *rng_dev_attrs[] = { |
464 | &dev_attr_rng_current.attr, | |
465 | &dev_attr_rng_available.attr, | |
10a515dd | 466 | &dev_attr_rng_selected.attr, |
82082856 | 467 | &dev_attr_rng_quality.attr, |
0daa7a0a TI |
468 | NULL |
469 | }; | |
470 | ||
471 | ATTRIBUTE_GROUPS(rng_dev); | |
844dd05f | 472 | |
ac3a497f | 473 | static void __exit unregister_miscdev(void) |
844dd05f | 474 | { |
b844eba2 | 475 | misc_deregister(&rng_miscdev); |
844dd05f MB |
476 | } |
477 | ||
ac3a497f | 478 | static int __init register_miscdev(void) |
844dd05f | 479 | { |
0daa7a0a | 480 | return misc_register(&rng_miscdev); |
844dd05f MB |
481 | } |
482 | ||
be4000bc TD |
483 | static int hwrng_fillfn(void *unused) |
484 | { | |
a43bed82 | 485 | size_t entropy, entropy_credit = 0; /* in 1/1024 of a bit */ |
be4000bc TD |
486 | long rc; |
487 | ||
08e97aec | 488 | while (!kthread_should_stop()) { |
f0fb6953 | 489 | unsigned short quality; |
3a2c0ba5 RR |
490 | struct hwrng *rng; |
491 | ||
492 | rng = get_current_rng(); | |
493 | if (IS_ERR(rng) || !rng) | |
be4000bc | 494 | break; |
9372b35e | 495 | mutex_lock(&reading_mutex); |
3a2c0ba5 | 496 | rc = rng_get_data(rng, rng_fillbuf, |
be4000bc | 497 | rng_buffer_size(), 1); |
f0fb6953 DB |
498 | if (current_quality != rng->quality) |
499 | rng->quality = current_quality; /* obsolete */ | |
500 | quality = rng->quality; | |
9372b35e | 501 | mutex_unlock(&reading_mutex); |
36cb6494 JD |
502 | |
503 | if (rc <= 0) | |
504 | hwrng_msleep(rng, 10000); | |
505 | ||
3a2c0ba5 | 506 | put_rng(rng); |
f0fb6953 | 507 | |
36cb6494 | 508 | if (rc <= 0) |
be4000bc | 509 | continue; |
a43bed82 DB |
510 | |
511 | /* If we cannot credit at least one bit of entropy, | |
512 | * keep track of the remainder for the next iteration | |
513 | */ | |
f0fb6953 | 514 | entropy = rc * quality * 8 + entropy_credit; |
a43bed82 DB |
515 | if ((entropy >> 10) == 0) |
516 | entropy_credit = entropy; | |
517 | ||
9372b35e | 518 | /* Outside lock, sure, but y'know: randomness. */ |
be4000bc | 519 | add_hwgenerator_randomness((void *)rng_fillbuf, rc, |
db516da9 | 520 | entropy >> 10, true); |
be4000bc | 521 | } |
9dda727d | 522 | hwrng_fill = NULL; |
be4000bc TD |
523 | return 0; |
524 | } | |
525 | ||
844dd05f MB |
526 | int hwrng_register(struct hwrng *rng) |
527 | { | |
844dd05f | 528 | int err = -EINVAL; |
28443671 | 529 | struct hwrng *tmp; |
844dd05f | 530 | |
2a971e3b | 531 | if (!rng->name || (!rng->data_read && !rng->read)) |
844dd05f MB |
532 | goto out; |
533 | ||
534 | mutex_lock(&rng_mutex); | |
daae28de | 535 | |
844dd05f MB |
536 | /* Must not register two RNGs with the same name. */ |
537 | err = -EEXIST; | |
538 | list_for_each_entry(tmp, &rng_list, list) { | |
539 | if (strcmp(tmp->name, rng->name) == 0) | |
540 | goto out_unlock; | |
541 | } | |
c90e4539 | 542 | list_add_tail(&rng->list, &rng_list); |
844dd05f | 543 | |
15b66cd5 HX |
544 | init_completion(&rng->cleanup_done); |
545 | complete(&rng->cleanup_done); | |
36cb6494 | 546 | init_completion(&rng->dying); |
15b66cd5 | 547 | |
28443671 LV |
548 | if (!current_rng || |
549 | (!cur_rng_set_by_user && rng->quality > current_rng->quality)) { | |
2bbb6983 HF |
550 | /* |
551 | * Set new rng as current as the new rng source | |
10a515dd HF |
552 | * provides better entropy quality and was not |
553 | * chosen by userspace. | |
2bbb6983 | 554 | */ |
90ac41bd | 555 | err = set_current_rng(rng); |
844dd05f MB |
556 | if (err) |
557 | goto out_unlock; | |
844dd05f | 558 | } |
daae28de | 559 | mutex_unlock(&rng_mutex); |
28443671 | 560 | return 0; |
844dd05f MB |
561 | out_unlock: |
562 | mutex_unlock(&rng_mutex); | |
563 | out: | |
564 | return err; | |
565 | } | |
566 | EXPORT_SYMBOL_GPL(hwrng_register); | |
567 | ||
b844eba2 | 568 | void hwrng_unregister(struct hwrng *rng) |
844dd05f | 569 | { |
67ec8cdf | 570 | struct hwrng *new_rng; |
837bf7cc MB |
571 | int err; |
572 | ||
844dd05f MB |
573 | mutex_lock(&rng_mutex); |
574 | ||
575 | list_del(&rng->list); | |
36cb6494 | 576 | complete_all(&rng->dying); |
837bf7cc MB |
577 | if (current_rng == rng) { |
578 | err = enable_best_rng(); | |
579 | if (err) { | |
580 | drop_current_rng(); | |
581 | cur_rng_set_by_user = 0; | |
582 | } | |
583 | } | |
3a2c0ba5 | 584 | |
daae28de | 585 | new_rng = get_current_rng_nolock(); |
be4000bc | 586 | if (list_empty(&rng_list)) { |
1dacb395 | 587 | mutex_unlock(&rng_mutex); |
be4000bc TD |
588 | if (hwrng_fill) |
589 | kthread_stop(hwrng_fill); | |
1dacb395 AK |
590 | } else |
591 | mutex_unlock(&rng_mutex); | |
a027f30d | 592 | |
67ec8cdf | 593 | if (new_rng) |
daae28de | 594 | put_rng(new_rng); |
daae28de | 595 | |
77584ee5 | 596 | wait_for_completion(&rng->cleanup_done); |
844dd05f | 597 | } |
b844eba2 | 598 | EXPORT_SYMBOL_GPL(hwrng_unregister); |
844dd05f | 599 | |
4d9b519c DT |
600 | static void devm_hwrng_release(struct device *dev, void *res) |
601 | { | |
602 | hwrng_unregister(*(struct hwrng **)res); | |
603 | } | |
604 | ||
605 | static int devm_hwrng_match(struct device *dev, void *res, void *data) | |
606 | { | |
607 | struct hwrng **r = res; | |
608 | ||
609 | if (WARN_ON(!r || !*r)) | |
610 | return 0; | |
611 | ||
612 | return *r == data; | |
613 | } | |
614 | ||
615 | int devm_hwrng_register(struct device *dev, struct hwrng *rng) | |
616 | { | |
617 | struct hwrng **ptr; | |
618 | int error; | |
619 | ||
620 | ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL); | |
621 | if (!ptr) | |
622 | return -ENOMEM; | |
623 | ||
624 | error = hwrng_register(rng); | |
625 | if (error) { | |
626 | devres_free(ptr); | |
627 | return error; | |
628 | } | |
629 | ||
630 | *ptr = rng; | |
631 | devres_add(dev, ptr); | |
632 | return 0; | |
633 | } | |
634 | EXPORT_SYMBOL_GPL(devm_hwrng_register); | |
635 | ||
636 | void devm_hwrng_unregister(struct device *dev, struct hwrng *rng) | |
637 | { | |
638 | devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng); | |
639 | } | |
640 | EXPORT_SYMBOL_GPL(devm_hwrng_unregister); | |
641 | ||
36cb6494 JD |
642 | long hwrng_msleep(struct hwrng *rng, unsigned int msecs) |
643 | { | |
644 | unsigned long timeout = msecs_to_jiffies(msecs) + 1; | |
645 | ||
646 | return wait_for_completion_interruptible_timeout(&rng->dying, timeout); | |
647 | } | |
648 | EXPORT_SYMBOL_GPL(hwrng_msleep); | |
649 | ||
b58a3600 SW |
650 | long hwrng_yield(struct hwrng *rng) |
651 | { | |
652 | return wait_for_completion_interruptible_timeout(&rng->dying, 1); | |
653 | } | |
654 | EXPORT_SYMBOL_GPL(hwrng_yield); | |
655 | ||
ac3a497f HX |
656 | static int __init hwrng_modinit(void) |
657 | { | |
45645709 | 658 | int ret; |
58b022ac PM |
659 | |
660 | /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ | |
661 | rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL); | |
662 | if (!rng_buffer) | |
663 | return -ENOMEM; | |
664 | ||
665 | rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL); | |
666 | if (!rng_fillbuf) { | |
667 | kfree(rng_buffer); | |
668 | return -ENOMEM; | |
669 | } | |
670 | ||
671 | ret = register_miscdev(); | |
672 | if (ret) { | |
673 | kfree(rng_fillbuf); | |
674 | kfree(rng_buffer); | |
675 | } | |
676 | ||
677 | return ret; | |
ac3a497f HX |
678 | } |
679 | ||
680 | static void __exit hwrng_modexit(void) | |
b7d44d94 ST |
681 | { |
682 | mutex_lock(&rng_mutex); | |
683 | BUG_ON(current_rng); | |
684 | kfree(rng_buffer); | |
be4000bc | 685 | kfree(rng_fillbuf); |
b7d44d94 | 686 | mutex_unlock(&rng_mutex); |
ac3a497f HX |
687 | |
688 | unregister_miscdev(); | |
b7d44d94 ST |
689 | } |
690 | ||
26a03981 | 691 | fs_initcall(hwrng_modinit); /* depends on misc_register() */ |
ac3a497f | 692 | module_exit(hwrng_modexit); |
844dd05f MB |
693 | |
694 | MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver"); | |
695 | MODULE_LICENSE("GPL"); |