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: | |
f0fb6953 | 164 | current_quality = rng->quality; /* obsolete */ |
0f734e6e | 165 | |
d3cc7996 | 166 | return 0; |
844dd05f MB |
167 | } |
168 | ||
844dd05f MB |
169 | static int rng_dev_open(struct inode *inode, struct file *filp) |
170 | { | |
171 | /* enforce read-only access to this chrdev */ | |
172 | if ((filp->f_mode & FMODE_READ) == 0) | |
173 | return -EINVAL; | |
174 | if (filp->f_mode & FMODE_WRITE) | |
175 | return -EINVAL; | |
176 | return 0; | |
177 | } | |
178 | ||
9996508b IM |
179 | static inline int rng_get_data(struct hwrng *rng, u8 *buffer, size_t size, |
180 | int wait) { | |
181 | int present; | |
182 | ||
9372b35e | 183 | BUG_ON(!mutex_is_locked(&reading_mutex)); |
fb10c7a8 HX |
184 | if (rng->read) { |
185 | int err; | |
186 | ||
187 | err = rng->read(rng, buffer, size, wait); | |
188 | if (WARN_ON_ONCE(err > 0 && err > size)) | |
189 | err = size; | |
190 | ||
191 | return err; | |
192 | } | |
9996508b IM |
193 | |
194 | if (rng->data_present) | |
195 | present = rng->data_present(rng, wait); | |
196 | else | |
197 | present = 1; | |
198 | ||
199 | if (present) | |
200 | return rng->data_read(rng, (u32 *)buffer); | |
201 | ||
202 | return 0; | |
203 | } | |
204 | ||
844dd05f MB |
205 | static ssize_t rng_dev_read(struct file *filp, char __user *buf, |
206 | size_t size, loff_t *offp) | |
207 | { | |
78aafb38 | 208 | u8 buffer[RNG_BUFFER_SIZE]; |
844dd05f | 209 | ssize_t ret = 0; |
984e976f | 210 | int err = 0; |
9996508b | 211 | int bytes_read, len; |
3a2c0ba5 | 212 | struct hwrng *rng; |
844dd05f MB |
213 | |
214 | while (size) { | |
3a2c0ba5 RR |
215 | rng = get_current_rng(); |
216 | if (IS_ERR(rng)) { | |
217 | err = PTR_ERR(rng); | |
844dd05f | 218 | goto out; |
9996508b | 219 | } |
3a2c0ba5 | 220 | if (!rng) { |
844dd05f | 221 | err = -ENODEV; |
3a2c0ba5 | 222 | goto out; |
844dd05f | 223 | } |
984e976f | 224 | |
1ab87298 JS |
225 | if (mutex_lock_interruptible(&reading_mutex)) { |
226 | err = -ERESTARTSYS; | |
227 | goto out_put; | |
228 | } | |
9996508b | 229 | if (!data_avail) { |
3a2c0ba5 | 230 | bytes_read = rng_get_data(rng, rng_buffer, |
f7f154f1 | 231 | rng_buffer_size(), |
9996508b IM |
232 | !(filp->f_flags & O_NONBLOCK)); |
233 | if (bytes_read < 0) { | |
234 | err = bytes_read; | |
9372b35e | 235 | goto out_unlock_reading; |
78aafb38 HX |
236 | } else if (bytes_read == 0 && |
237 | (filp->f_flags & O_NONBLOCK)) { | |
238 | err = -EAGAIN; | |
239 | goto out_unlock_reading; | |
9996508b | 240 | } |
78aafb38 | 241 | |
9996508b | 242 | data_avail = bytes_read; |
893f1128 | 243 | } |
844dd05f | 244 | |
78aafb38 HX |
245 | len = data_avail; |
246 | if (len) { | |
9996508b IM |
247 | if (len > size) |
248 | len = size; | |
249 | ||
250 | data_avail -= len; | |
251 | ||
78aafb38 HX |
252 | memcpy(buffer, rng_buffer + data_avail, len); |
253 | } | |
254 | mutex_unlock(&reading_mutex); | |
255 | put_rng(rng); | |
256 | ||
257 | if (len) { | |
258 | if (copy_to_user(buf + ret, buffer, len)) { | |
9996508b | 259 | err = -EFAULT; |
78aafb38 | 260 | goto out; |
9996508b IM |
261 | } |
262 | ||
263 | size -= len; | |
264 | ret += len; | |
844dd05f MB |
265 | } |
266 | ||
9996508b | 267 | |
844dd05f MB |
268 | if (need_resched()) |
269 | schedule_timeout_interruptible(1); | |
9996508b IM |
270 | |
271 | if (signal_pending(current)) { | |
272 | err = -ERESTARTSYS; | |
844dd05f | 273 | goto out; |
9996508b | 274 | } |
844dd05f MB |
275 | } |
276 | out: | |
78aafb38 | 277 | memzero_explicit(buffer, sizeof(buffer)); |
844dd05f | 278 | return ret ? : err; |
3a2c0ba5 | 279 | |
9372b35e RR |
280 | out_unlock_reading: |
281 | mutex_unlock(&reading_mutex); | |
1ab87298 | 282 | out_put: |
3a2c0ba5 RR |
283 | put_rng(rng); |
284 | goto out; | |
844dd05f MB |
285 | } |
286 | ||
62322d25 | 287 | static const struct file_operations rng_chrdev_ops = { |
844dd05f MB |
288 | .owner = THIS_MODULE, |
289 | .open = rng_dev_open, | |
290 | .read = rng_dev_read, | |
6038f373 | 291 | .llseek = noop_llseek, |
844dd05f MB |
292 | }; |
293 | ||
0daa7a0a TI |
294 | static const struct attribute_group *rng_dev_groups[]; |
295 | ||
844dd05f | 296 | static struct miscdevice rng_miscdev = { |
fd50d71f | 297 | .minor = HWRNG_MINOR, |
844dd05f | 298 | .name = RNG_MODULE_NAME, |
e454cea2 | 299 | .nodename = "hwrng", |
844dd05f | 300 | .fops = &rng_chrdev_ops, |
0daa7a0a | 301 | .groups = rng_dev_groups, |
844dd05f MB |
302 | }; |
303 | ||
142a27f0 PM |
304 | static int enable_best_rng(void) |
305 | { | |
c90e4539 | 306 | struct hwrng *rng, *new_rng = NULL; |
142a27f0 PM |
307 | int ret = -ENODEV; |
308 | ||
309 | BUG_ON(!mutex_is_locked(&rng_mutex)); | |
310 | ||
c90e4539 DB |
311 | /* no rng to use? */ |
312 | if (list_empty(&rng_list)) { | |
0e4b5294 GH |
313 | drop_current_rng(); |
314 | cur_rng_set_by_user = 0; | |
c90e4539 DB |
315 | return 0; |
316 | } | |
317 | ||
318 | /* use the rng which offers the best quality */ | |
319 | list_for_each_entry(rng, &rng_list, list) { | |
320 | if (!new_rng || rng->quality > new_rng->quality) | |
321 | new_rng = rng; | |
142a27f0 PM |
322 | } |
323 | ||
c90e4539 DB |
324 | ret = ((new_rng == current_rng) ? 0 : set_current_rng(new_rng)); |
325 | if (!ret) | |
326 | cur_rng_set_by_user = 0; | |
327 | ||
142a27f0 PM |
328 | return ret; |
329 | } | |
330 | ||
98f481f2 Y |
331 | static ssize_t rng_current_store(struct device *dev, |
332 | struct device_attribute *attr, | |
333 | const char *buf, size_t len) | |
844dd05f | 334 | { |
cb028f16 | 335 | int err; |
67ec8cdf | 336 | struct hwrng *rng, *new_rng; |
844dd05f MB |
337 | |
338 | err = mutex_lock_interruptible(&rng_mutex); | |
339 | if (err) | |
340 | return -ERESTARTSYS; | |
142a27f0 PM |
341 | |
342 | if (sysfs_streq(buf, "")) { | |
343 | err = enable_best_rng(); | |
344 | } else { | |
345 | list_for_each_entry(rng, &rng_list, list) { | |
346 | if (sysfs_streq(rng->name, buf)) { | |
90ac41bd | 347 | err = set_current_rng(rng); |
f41aa47c DB |
348 | if (!err) |
349 | cur_rng_set_by_user = 1; | |
142a27f0 PM |
350 | break; |
351 | } | |
844dd05f MB |
352 | } |
353 | } | |
daae28de | 354 | new_rng = get_current_rng_nolock(); |
844dd05f MB |
355 | mutex_unlock(&rng_mutex); |
356 | ||
67ec8cdf | 357 | if (new_rng) |
daae28de | 358 | put_rng(new_rng); |
daae28de | 359 | |
844dd05f MB |
360 | return err ? : len; |
361 | } | |
362 | ||
98f481f2 Y |
363 | static ssize_t rng_current_show(struct device *dev, |
364 | struct device_attribute *attr, | |
365 | char *buf) | |
844dd05f | 366 | { |
844dd05f | 367 | ssize_t ret; |
3a2c0ba5 | 368 | struct hwrng *rng; |
844dd05f | 369 | |
3a2c0ba5 RR |
370 | rng = get_current_rng(); |
371 | if (IS_ERR(rng)) | |
372 | return PTR_ERR(rng); | |
373 | ||
90d012fb | 374 | ret = sysfs_emit(buf, "%s\n", rng ? rng->name : "none"); |
3a2c0ba5 | 375 | put_rng(rng); |
844dd05f MB |
376 | |
377 | return ret; | |
378 | } | |
379 | ||
98f481f2 Y |
380 | static ssize_t rng_available_show(struct device *dev, |
381 | struct device_attribute *attr, | |
382 | char *buf) | |
844dd05f MB |
383 | { |
384 | int err; | |
844dd05f MB |
385 | struct hwrng *rng; |
386 | ||
387 | err = mutex_lock_interruptible(&rng_mutex); | |
388 | if (err) | |
389 | return -ERESTARTSYS; | |
390 | buf[0] = '\0'; | |
391 | list_for_each_entry(rng, &rng_list, list) { | |
61daf055 RS |
392 | strlcat(buf, rng->name, PAGE_SIZE); |
393 | strlcat(buf, " ", PAGE_SIZE); | |
844dd05f | 394 | } |
61daf055 | 395 | strlcat(buf, "\n", PAGE_SIZE); |
844dd05f MB |
396 | mutex_unlock(&rng_mutex); |
397 | ||
61daf055 | 398 | return strlen(buf); |
844dd05f MB |
399 | } |
400 | ||
98f481f2 Y |
401 | static ssize_t rng_selected_show(struct device *dev, |
402 | struct device_attribute *attr, | |
403 | char *buf) | |
10a515dd | 404 | { |
91253022 | 405 | return sysfs_emit(buf, "%d\n", cur_rng_set_by_user); |
10a515dd HF |
406 | } |
407 | ||
82082856 DB |
408 | static ssize_t rng_quality_show(struct device *dev, |
409 | struct device_attribute *attr, | |
410 | char *buf) | |
411 | { | |
412 | ssize_t ret; | |
413 | struct hwrng *rng; | |
414 | ||
415 | rng = get_current_rng(); | |
416 | if (IS_ERR(rng)) | |
417 | return PTR_ERR(rng); | |
418 | ||
419 | if (!rng) /* no need to put_rng */ | |
420 | return -ENODEV; | |
421 | ||
422 | ret = sysfs_emit(buf, "%hu\n", rng->quality); | |
423 | put_rng(rng); | |
424 | ||
425 | return ret; | |
426 | } | |
427 | ||
428 | static ssize_t rng_quality_store(struct device *dev, | |
429 | struct device_attribute *attr, | |
430 | const char *buf, size_t len) | |
431 | { | |
432 | u16 quality; | |
433 | int ret = -EINVAL; | |
434 | ||
435 | if (len < 2) | |
436 | return -EINVAL; | |
437 | ||
438 | ret = mutex_lock_interruptible(&rng_mutex); | |
439 | if (ret) | |
440 | return -ERESTARTSYS; | |
441 | ||
442 | ret = kstrtou16(buf, 0, &quality); | |
443 | if (ret || quality > 1024) { | |
444 | ret = -EINVAL; | |
445 | goto out; | |
446 | } | |
447 | ||
448 | if (!current_rng) { | |
449 | ret = -ENODEV; | |
450 | goto out; | |
451 | } | |
452 | ||
453 | current_rng->quality = quality; | |
454 | current_quality = quality; /* obsolete */ | |
455 | ||
456 | /* the best available RNG may have changed */ | |
457 | ret = enable_best_rng(); | |
458 | ||
82082856 DB |
459 | out: |
460 | mutex_unlock(&rng_mutex); | |
461 | return ret ? ret : len; | |
462 | } | |
463 | ||
98f481f2 Y |
464 | static DEVICE_ATTR_RW(rng_current); |
465 | static DEVICE_ATTR_RO(rng_available); | |
466 | static DEVICE_ATTR_RO(rng_selected); | |
82082856 | 467 | static DEVICE_ATTR_RW(rng_quality); |
844dd05f | 468 | |
0daa7a0a TI |
469 | static struct attribute *rng_dev_attrs[] = { |
470 | &dev_attr_rng_current.attr, | |
471 | &dev_attr_rng_available.attr, | |
10a515dd | 472 | &dev_attr_rng_selected.attr, |
82082856 | 473 | &dev_attr_rng_quality.attr, |
0daa7a0a TI |
474 | NULL |
475 | }; | |
476 | ||
477 | ATTRIBUTE_GROUPS(rng_dev); | |
844dd05f | 478 | |
be4000bc TD |
479 | static int hwrng_fillfn(void *unused) |
480 | { | |
a43bed82 | 481 | size_t entropy, entropy_credit = 0; /* in 1/1024 of a bit */ |
be4000bc TD |
482 | long rc; |
483 | ||
08e97aec | 484 | while (!kthread_should_stop()) { |
f0fb6953 | 485 | unsigned short quality; |
3a2c0ba5 RR |
486 | struct hwrng *rng; |
487 | ||
488 | rng = get_current_rng(); | |
489 | if (IS_ERR(rng) || !rng) | |
be4000bc | 490 | break; |
9372b35e | 491 | mutex_lock(&reading_mutex); |
3a2c0ba5 | 492 | rc = rng_get_data(rng, rng_fillbuf, |
be4000bc | 493 | rng_buffer_size(), 1); |
f0fb6953 DB |
494 | if (current_quality != rng->quality) |
495 | rng->quality = current_quality; /* obsolete */ | |
496 | quality = rng->quality; | |
9372b35e | 497 | mutex_unlock(&reading_mutex); |
36cb6494 JD |
498 | |
499 | if (rc <= 0) | |
500 | hwrng_msleep(rng, 10000); | |
501 | ||
3a2c0ba5 | 502 | put_rng(rng); |
f0fb6953 | 503 | |
36cb6494 | 504 | if (rc <= 0) |
be4000bc | 505 | continue; |
a43bed82 DB |
506 | |
507 | /* If we cannot credit at least one bit of entropy, | |
508 | * keep track of the remainder for the next iteration | |
509 | */ | |
f0fb6953 | 510 | entropy = rc * quality * 8 + entropy_credit; |
a43bed82 DB |
511 | if ((entropy >> 10) == 0) |
512 | entropy_credit = entropy; | |
513 | ||
9372b35e | 514 | /* Outside lock, sure, but y'know: randomness. */ |
be4000bc | 515 | add_hwgenerator_randomness((void *)rng_fillbuf, rc, |
db516da9 | 516 | entropy >> 10, true); |
be4000bc | 517 | } |
9dda727d | 518 | hwrng_fill = NULL; |
be4000bc TD |
519 | return 0; |
520 | } | |
521 | ||
844dd05f MB |
522 | int hwrng_register(struct hwrng *rng) |
523 | { | |
844dd05f | 524 | int err = -EINVAL; |
28443671 | 525 | struct hwrng *tmp; |
844dd05f | 526 | |
2a971e3b | 527 | if (!rng->name || (!rng->data_read && !rng->read)) |
844dd05f MB |
528 | goto out; |
529 | ||
530 | mutex_lock(&rng_mutex); | |
daae28de | 531 | |
844dd05f MB |
532 | /* Must not register two RNGs with the same name. */ |
533 | err = -EEXIST; | |
534 | list_for_each_entry(tmp, &rng_list, list) { | |
535 | if (strcmp(tmp->name, rng->name) == 0) | |
536 | goto out_unlock; | |
537 | } | |
c90e4539 | 538 | list_add_tail(&rng->list, &rng_list); |
844dd05f | 539 | |
15b66cd5 HX |
540 | init_completion(&rng->cleanup_done); |
541 | complete(&rng->cleanup_done); | |
36cb6494 | 542 | init_completion(&rng->dying); |
15b66cd5 | 543 | |
95c0f5c3 HF |
544 | /* Adjust quality field to always have a proper value */ |
545 | rng->quality = min_t(u16, min_t(u16, default_quality, 1024), rng->quality ?: 1024); | |
546 | ||
28443671 LV |
547 | if (!current_rng || |
548 | (!cur_rng_set_by_user && rng->quality > current_rng->quality)) { | |
2bbb6983 HF |
549 | /* |
550 | * Set new rng as current as the new rng source | |
10a515dd HF |
551 | * provides better entropy quality and was not |
552 | * chosen by userspace. | |
2bbb6983 | 553 | */ |
90ac41bd | 554 | err = set_current_rng(rng); |
844dd05f MB |
555 | if (err) |
556 | goto out_unlock; | |
844dd05f | 557 | } |
daae28de | 558 | mutex_unlock(&rng_mutex); |
28443671 | 559 | return 0; |
844dd05f MB |
560 | out_unlock: |
561 | mutex_unlock(&rng_mutex); | |
562 | out: | |
563 | return err; | |
564 | } | |
565 | EXPORT_SYMBOL_GPL(hwrng_register); | |
566 | ||
b844eba2 | 567 | void hwrng_unregister(struct hwrng *rng) |
844dd05f | 568 | { |
67ec8cdf | 569 | struct hwrng *new_rng; |
837bf7cc MB |
570 | int err; |
571 | ||
844dd05f MB |
572 | mutex_lock(&rng_mutex); |
573 | ||
574 | list_del(&rng->list); | |
36cb6494 | 575 | complete_all(&rng->dying); |
837bf7cc MB |
576 | if (current_rng == rng) { |
577 | err = enable_best_rng(); | |
578 | if (err) { | |
579 | drop_current_rng(); | |
580 | cur_rng_set_by_user = 0; | |
581 | } | |
582 | } | |
3a2c0ba5 | 583 | |
daae28de | 584 | new_rng = get_current_rng_nolock(); |
be4000bc | 585 | if (list_empty(&rng_list)) { |
1dacb395 | 586 | mutex_unlock(&rng_mutex); |
be4000bc TD |
587 | if (hwrng_fill) |
588 | kthread_stop(hwrng_fill); | |
1dacb395 AK |
589 | } else |
590 | mutex_unlock(&rng_mutex); | |
a027f30d | 591 | |
67ec8cdf | 592 | if (new_rng) |
daae28de | 593 | put_rng(new_rng); |
daae28de | 594 | |
77584ee5 | 595 | wait_for_completion(&rng->cleanup_done); |
844dd05f | 596 | } |
b844eba2 | 597 | EXPORT_SYMBOL_GPL(hwrng_unregister); |
844dd05f | 598 | |
4d9b519c DT |
599 | static void devm_hwrng_release(struct device *dev, void *res) |
600 | { | |
601 | hwrng_unregister(*(struct hwrng **)res); | |
602 | } | |
603 | ||
604 | static int devm_hwrng_match(struct device *dev, void *res, void *data) | |
605 | { | |
606 | struct hwrng **r = res; | |
607 | ||
608 | if (WARN_ON(!r || !*r)) | |
609 | return 0; | |
610 | ||
611 | return *r == data; | |
612 | } | |
613 | ||
614 | int devm_hwrng_register(struct device *dev, struct hwrng *rng) | |
615 | { | |
616 | struct hwrng **ptr; | |
617 | int error; | |
618 | ||
619 | ptr = devres_alloc(devm_hwrng_release, sizeof(*ptr), GFP_KERNEL); | |
620 | if (!ptr) | |
621 | return -ENOMEM; | |
622 | ||
623 | error = hwrng_register(rng); | |
624 | if (error) { | |
625 | devres_free(ptr); | |
626 | return error; | |
627 | } | |
628 | ||
629 | *ptr = rng; | |
630 | devres_add(dev, ptr); | |
631 | return 0; | |
632 | } | |
633 | EXPORT_SYMBOL_GPL(devm_hwrng_register); | |
634 | ||
635 | void devm_hwrng_unregister(struct device *dev, struct hwrng *rng) | |
636 | { | |
637 | devres_release(dev, devm_hwrng_release, devm_hwrng_match, rng); | |
638 | } | |
639 | EXPORT_SYMBOL_GPL(devm_hwrng_unregister); | |
640 | ||
36cb6494 JD |
641 | long hwrng_msleep(struct hwrng *rng, unsigned int msecs) |
642 | { | |
643 | unsigned long timeout = msecs_to_jiffies(msecs) + 1; | |
644 | ||
645 | return wait_for_completion_interruptible_timeout(&rng->dying, timeout); | |
646 | } | |
647 | EXPORT_SYMBOL_GPL(hwrng_msleep); | |
648 | ||
b58a3600 SW |
649 | long hwrng_yield(struct hwrng *rng) |
650 | { | |
651 | return wait_for_completion_interruptible_timeout(&rng->dying, 1); | |
652 | } | |
653 | EXPORT_SYMBOL_GPL(hwrng_yield); | |
654 | ||
ac3a497f HX |
655 | static int __init hwrng_modinit(void) |
656 | { | |
45645709 | 657 | int ret; |
58b022ac PM |
658 | |
659 | /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ | |
660 | rng_buffer = kmalloc(rng_buffer_size(), GFP_KERNEL); | |
661 | if (!rng_buffer) | |
662 | return -ENOMEM; | |
663 | ||
664 | rng_fillbuf = kmalloc(rng_buffer_size(), GFP_KERNEL); | |
665 | if (!rng_fillbuf) { | |
666 | kfree(rng_buffer); | |
667 | return -ENOMEM; | |
668 | } | |
669 | ||
df1e9791 | 670 | ret = misc_register(&rng_miscdev); |
58b022ac PM |
671 | if (ret) { |
672 | kfree(rng_fillbuf); | |
673 | kfree(rng_buffer); | |
674 | } | |
675 | ||
676 | return ret; | |
ac3a497f HX |
677 | } |
678 | ||
679 | static void __exit hwrng_modexit(void) | |
b7d44d94 ST |
680 | { |
681 | mutex_lock(&rng_mutex); | |
682 | BUG_ON(current_rng); | |
683 | kfree(rng_buffer); | |
be4000bc | 684 | kfree(rng_fillbuf); |
b7d44d94 | 685 | mutex_unlock(&rng_mutex); |
ac3a497f | 686 | |
df1e9791 | 687 | misc_deregister(&rng_miscdev); |
b7d44d94 ST |
688 | } |
689 | ||
26a03981 | 690 | fs_initcall(hwrng_modinit); /* depends on misc_register() */ |
ac3a497f | 691 | module_exit(hwrng_modexit); |
844dd05f MB |
692 | |
693 | MODULE_DESCRIPTION("H/W Random Number Generator (RNG) driver"); | |
694 | MODULE_LICENSE("GPL"); |