1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2001, 2002 Sistina Software (UK) Limited. |
4 | * Copyright (C) 2004 - 2006 Red Hat, Inc. All rights reserved. |
5 | * |
6 | * This file is released under the GPL. |
7 | */ |
8 | |
9 | #include "dm-core.h" |
10 | #include "dm-ima.h" |
11 | #include <linux/module.h> |
12 | #include <linux/vmalloc.h> |
13 | #include <linux/miscdevice.h> |
14 | #include <linux/sched/mm.h> |
15 | #include <linux/init.h> |
16 | #include <linux/wait.h> |
17 | #include <linux/slab.h> |
18 | #include <linux/rbtree.h> |
19 | #include <linux/dm-ioctl.h> |
20 | #include <linux/hdreg.h> |
21 | #include <linux/compat.h> |
22 | #include <linux/nospec.h> |
23 | |
24 | #include <linux/uaccess.h> |
25 | #include <linux/ima.h> |
26 | |
27 | #define DM_MSG_PREFIX "ioctl" |
28 | #define DM_DRIVER_EMAIL "dm-devel@redhat.com" |
29 | |
30 | struct dm_file { |
31 | /* |
32 | * poll will wait until the global event number is greater than |
33 | * this value. |
34 | */ |
35 | volatile unsigned int global_event_nr; |
36 | }; |
37 | |
38 | /* |
39 | *--------------------------------------------------------------- |
40 | * The ioctl interface needs to be able to look up devices by |
41 | * name or uuid. |
42 | *--------------------------------------------------------------- |
43 | */ |
44 | struct hash_cell { |
45 | struct rb_node name_node; |
46 | struct rb_node uuid_node; |
47 | bool name_set; |
48 | bool uuid_set; |
49 | |
50 | char *name; |
51 | char *uuid; |
52 | struct mapped_device *md; |
53 | struct dm_table *new_map; |
54 | }; |
55 | |
56 | struct vers_iter { |
57 | size_t param_size; |
58 | struct dm_target_versions *vers, *old_vers; |
59 | char *end; |
60 | uint32_t flags; |
61 | }; |
62 | |
63 | |
64 | static struct rb_root name_rb_tree = RB_ROOT; |
65 | static struct rb_root uuid_rb_tree = RB_ROOT; |
66 | |
67 | static void dm_hash_remove_all(bool keep_open_devices, bool mark_deferred, bool only_deferred); |
68 | |
69 | /* |
70 | * Guards access to both hash tables. |
71 | */ |
72 | static DECLARE_RWSEM(_hash_lock); |
73 | |
74 | /* |
75 | * Protects use of mdptr to obtain hash cell name and uuid from mapped device. |
76 | */ |
77 | static DEFINE_MUTEX(dm_hash_cells_mutex); |
78 | |
79 | static void dm_hash_exit(void) |
80 | { |
81 | dm_hash_remove_all(keep_open_devices: false, mark_deferred: false, only_deferred: false); |
82 | } |
83 | |
84 | /* |
85 | *--------------------------------------------------------------- |
86 | * Code for looking up a device by name |
87 | *--------------------------------------------------------------- |
88 | */ |
89 | static struct hash_cell *__get_name_cell(const char *str) |
90 | { |
91 | struct rb_node *n = name_rb_tree.rb_node; |
92 | |
93 | while (n) { |
94 | struct hash_cell *hc = container_of(n, struct hash_cell, name_node); |
95 | int c; |
96 | |
97 | c = strcmp(hc->name, str); |
98 | if (!c) { |
99 | dm_get(md: hc->md); |
100 | return hc; |
101 | } |
102 | n = c >= 0 ? n->rb_left : n->rb_right; |
103 | } |
104 | |
105 | return NULL; |
106 | } |
107 | |
108 | static struct hash_cell *__get_uuid_cell(const char *str) |
109 | { |
110 | struct rb_node *n = uuid_rb_tree.rb_node; |
111 | |
112 | while (n) { |
113 | struct hash_cell *hc = container_of(n, struct hash_cell, uuid_node); |
114 | int c; |
115 | |
116 | c = strcmp(hc->uuid, str); |
117 | if (!c) { |
118 | dm_get(md: hc->md); |
119 | return hc; |
120 | } |
121 | n = c >= 0 ? n->rb_left : n->rb_right; |
122 | } |
123 | |
124 | return NULL; |
125 | } |
126 | |
127 | static void __unlink_name(struct hash_cell *hc) |
128 | { |
129 | if (hc->name_set) { |
130 | hc->name_set = false; |
131 | rb_erase(&hc->name_node, &name_rb_tree); |
132 | } |
133 | } |
134 | |
135 | static void __unlink_uuid(struct hash_cell *hc) |
136 | { |
137 | if (hc->uuid_set) { |
138 | hc->uuid_set = false; |
139 | rb_erase(&hc->uuid_node, &uuid_rb_tree); |
140 | } |
141 | } |
142 | |
143 | static void __link_name(struct hash_cell *new_hc) |
144 | { |
145 | struct rb_node **n, *parent; |
146 | |
147 | __unlink_name(hc: new_hc); |
148 | |
149 | new_hc->name_set = true; |
150 | |
151 | n = &name_rb_tree.rb_node; |
152 | parent = NULL; |
153 | |
154 | while (*n) { |
155 | struct hash_cell *hc = container_of(*n, struct hash_cell, name_node); |
156 | int c; |
157 | |
158 | c = strcmp(hc->name, new_hc->name); |
159 | BUG_ON(!c); |
160 | parent = *n; |
161 | n = c >= 0 ? &hc->name_node.rb_left : &hc->name_node.rb_right; |
162 | } |
163 | |
164 | rb_link_node(node: &new_hc->name_node, parent, rb_link: n); |
165 | rb_insert_color(&new_hc->name_node, &name_rb_tree); |
166 | } |
167 | |
168 | static void __link_uuid(struct hash_cell *new_hc) |
169 | { |
170 | struct rb_node **n, *parent; |
171 | |
172 | __unlink_uuid(hc: new_hc); |
173 | |
174 | new_hc->uuid_set = true; |
175 | |
176 | n = &uuid_rb_tree.rb_node; |
177 | parent = NULL; |
178 | |
179 | while (*n) { |
180 | struct hash_cell *hc = container_of(*n, struct hash_cell, uuid_node); |
181 | int c; |
182 | |
183 | c = strcmp(hc->uuid, new_hc->uuid); |
184 | BUG_ON(!c); |
185 | parent = *n; |
186 | n = c > 0 ? &hc->uuid_node.rb_left : &hc->uuid_node.rb_right; |
187 | } |
188 | |
189 | rb_link_node(node: &new_hc->uuid_node, parent, rb_link: n); |
190 | rb_insert_color(&new_hc->uuid_node, &uuid_rb_tree); |
191 | } |
192 | |
193 | static struct hash_cell *__get_dev_cell(uint64_t dev) |
194 | { |
195 | struct mapped_device *md; |
196 | struct hash_cell *hc; |
197 | |
198 | md = dm_get_md(dev: huge_decode_dev(dev)); |
199 | if (!md) |
200 | return NULL; |
201 | |
202 | hc = dm_get_mdptr(md); |
203 | if (!hc) { |
204 | dm_put(md); |
205 | return NULL; |
206 | } |
207 | |
208 | return hc; |
209 | } |
210 | |
211 | /* |
212 | *--------------------------------------------------------------- |
213 | * Inserting, removing and renaming a device. |
214 | *--------------------------------------------------------------- |
215 | */ |
216 | static struct hash_cell *alloc_cell(const char *name, const char *uuid, |
217 | struct mapped_device *md) |
218 | { |
219 | struct hash_cell *hc; |
220 | |
221 | hc = kmalloc(size: sizeof(*hc), GFP_KERNEL); |
222 | if (!hc) |
223 | return NULL; |
224 | |
225 | hc->name = kstrdup(s: name, GFP_KERNEL); |
226 | if (!hc->name) { |
227 | kfree(objp: hc); |
228 | return NULL; |
229 | } |
230 | |
231 | if (!uuid) |
232 | hc->uuid = NULL; |
233 | |
234 | else { |
235 | hc->uuid = kstrdup(s: uuid, GFP_KERNEL); |
236 | if (!hc->uuid) { |
237 | kfree(objp: hc->name); |
238 | kfree(objp: hc); |
239 | return NULL; |
240 | } |
241 | } |
242 | |
243 | hc->name_set = hc->uuid_set = false; |
244 | hc->md = md; |
245 | hc->new_map = NULL; |
246 | return hc; |
247 | } |
248 | |
249 | static void free_cell(struct hash_cell *hc) |
250 | { |
251 | if (hc) { |
252 | kfree(objp: hc->name); |
253 | kfree(objp: hc->uuid); |
254 | kfree(objp: hc); |
255 | } |
256 | } |
257 | |
258 | /* |
259 | * The kdev_t and uuid of a device can never change once it is |
260 | * initially inserted. |
261 | */ |
262 | static int dm_hash_insert(const char *name, const char *uuid, struct mapped_device *md) |
263 | { |
264 | struct hash_cell *cell, *hc; |
265 | |
266 | /* |
267 | * Allocate the new cells. |
268 | */ |
269 | cell = alloc_cell(name, uuid, md); |
270 | if (!cell) |
271 | return -ENOMEM; |
272 | |
273 | /* |
274 | * Insert the cell into both hash tables. |
275 | */ |
276 | down_write(sem: &_hash_lock); |
277 | hc = __get_name_cell(str: name); |
278 | if (hc) { |
279 | dm_put(md: hc->md); |
280 | goto bad; |
281 | } |
282 | |
283 | __link_name(new_hc: cell); |
284 | |
285 | if (uuid) { |
286 | hc = __get_uuid_cell(str: uuid); |
287 | if (hc) { |
288 | __unlink_name(hc: cell); |
289 | dm_put(md: hc->md); |
290 | goto bad; |
291 | } |
292 | __link_uuid(new_hc: cell); |
293 | } |
294 | dm_get(md); |
295 | mutex_lock(&dm_hash_cells_mutex); |
296 | dm_set_mdptr(md, ptr: cell); |
297 | mutex_unlock(lock: &dm_hash_cells_mutex); |
298 | up_write(sem: &_hash_lock); |
299 | |
300 | return 0; |
301 | |
302 | bad: |
303 | up_write(sem: &_hash_lock); |
304 | free_cell(hc: cell); |
305 | return -EBUSY; |
306 | } |
307 | |
308 | static struct dm_table *__hash_remove(struct hash_cell *hc) |
309 | { |
310 | struct dm_table *table; |
311 | int srcu_idx; |
312 | |
313 | lockdep_assert_held(&_hash_lock); |
314 | |
315 | /* remove from the dev trees */ |
316 | __unlink_name(hc); |
317 | __unlink_uuid(hc); |
318 | mutex_lock(&dm_hash_cells_mutex); |
319 | dm_set_mdptr(md: hc->md, NULL); |
320 | mutex_unlock(lock: &dm_hash_cells_mutex); |
321 | |
322 | table = dm_get_live_table(md: hc->md, srcu_idx: &srcu_idx); |
323 | if (table) |
324 | dm_table_event(t: table); |
325 | dm_put_live_table(md: hc->md, srcu_idx); |
326 | |
327 | table = NULL; |
328 | if (hc->new_map) |
329 | table = hc->new_map; |
330 | dm_put(md: hc->md); |
331 | free_cell(hc); |
332 | |
333 | return table; |
334 | } |
335 | |
336 | static void dm_hash_remove_all(bool keep_open_devices, bool mark_deferred, bool only_deferred) |
337 | { |
338 | int dev_skipped; |
339 | struct rb_node *n; |
340 | struct hash_cell *hc; |
341 | struct mapped_device *md; |
342 | struct dm_table *t; |
343 | |
344 | retry: |
345 | dev_skipped = 0; |
346 | |
347 | down_write(sem: &_hash_lock); |
348 | |
349 | for (n = rb_first(&name_rb_tree); n; n = rb_next(n)) { |
350 | hc = container_of(n, struct hash_cell, name_node); |
351 | md = hc->md; |
352 | dm_get(md); |
353 | |
354 | if (keep_open_devices && |
355 | dm_lock_for_deletion(md, mark_deferred, only_deferred)) { |
356 | dm_put(md); |
357 | dev_skipped++; |
358 | continue; |
359 | } |
360 | |
361 | t = __hash_remove(hc); |
362 | |
363 | up_write(sem: &_hash_lock); |
364 | |
365 | if (t) { |
366 | dm_sync_table(md); |
367 | dm_table_destroy(t); |
368 | } |
369 | dm_ima_measure_on_device_remove(md, remove_all: true); |
370 | dm_put(md); |
371 | if (likely(keep_open_devices)) |
372 | dm_destroy(md); |
373 | else |
374 | dm_destroy_immediate(md); |
375 | |
376 | /* |
377 | * Some mapped devices may be using other mapped |
378 | * devices, so repeat until we make no further |
379 | * progress. If a new mapped device is created |
380 | * here it will also get removed. |
381 | */ |
382 | goto retry; |
383 | } |
384 | |
385 | up_write(sem: &_hash_lock); |
386 | |
387 | if (dev_skipped) |
388 | DMWARN("remove_all left %d open device(s)" , dev_skipped); |
389 | } |
390 | |
391 | /* |
392 | * Set the uuid of a hash_cell that isn't already set. |
393 | */ |
394 | static void __set_cell_uuid(struct hash_cell *hc, char *new_uuid) |
395 | { |
396 | mutex_lock(&dm_hash_cells_mutex); |
397 | hc->uuid = new_uuid; |
398 | mutex_unlock(lock: &dm_hash_cells_mutex); |
399 | |
400 | __link_uuid(new_hc: hc); |
401 | } |
402 | |
403 | /* |
404 | * Changes the name of a hash_cell and returns the old name for |
405 | * the caller to free. |
406 | */ |
407 | static char *__change_cell_name(struct hash_cell *hc, char *new_name) |
408 | { |
409 | char *old_name; |
410 | |
411 | /* |
412 | * Rename and move the name cell. |
413 | */ |
414 | __unlink_name(hc); |
415 | old_name = hc->name; |
416 | |
417 | mutex_lock(&dm_hash_cells_mutex); |
418 | hc->name = new_name; |
419 | mutex_unlock(lock: &dm_hash_cells_mutex); |
420 | |
421 | __link_name(new_hc: hc); |
422 | |
423 | return old_name; |
424 | } |
425 | |
426 | static struct mapped_device *dm_hash_rename(struct dm_ioctl *param, |
427 | const char *new) |
428 | { |
429 | char *new_data, *old_name = NULL; |
430 | struct hash_cell *hc; |
431 | struct dm_table *table; |
432 | struct mapped_device *md; |
433 | unsigned int change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0; |
434 | int srcu_idx; |
435 | |
436 | /* |
437 | * duplicate new. |
438 | */ |
439 | new_data = kstrdup(s: new, GFP_KERNEL); |
440 | if (!new_data) |
441 | return ERR_PTR(error: -ENOMEM); |
442 | |
443 | down_write(sem: &_hash_lock); |
444 | |
445 | /* |
446 | * Is new free ? |
447 | */ |
448 | if (change_uuid) |
449 | hc = __get_uuid_cell(str: new); |
450 | else |
451 | hc = __get_name_cell(str: new); |
452 | |
453 | if (hc) { |
454 | DMERR("Unable to change %s on mapped device %s to one that already exists: %s" , |
455 | change_uuid ? "uuid" : "name" , |
456 | param->name, new); |
457 | dm_put(md: hc->md); |
458 | up_write(sem: &_hash_lock); |
459 | kfree(objp: new_data); |
460 | return ERR_PTR(error: -EBUSY); |
461 | } |
462 | |
463 | /* |
464 | * Is there such a device as 'old' ? |
465 | */ |
466 | hc = __get_name_cell(str: param->name); |
467 | if (!hc) { |
468 | DMERR("Unable to rename non-existent device, %s to %s%s" , |
469 | param->name, change_uuid ? "uuid " : "" , new); |
470 | up_write(sem: &_hash_lock); |
471 | kfree(objp: new_data); |
472 | return ERR_PTR(error: -ENXIO); |
473 | } |
474 | |
475 | /* |
476 | * Does this device already have a uuid? |
477 | */ |
478 | if (change_uuid && hc->uuid) { |
479 | DMERR("Unable to change uuid of mapped device %s to %s " |
480 | "because uuid is already set to %s" , |
481 | param->name, new, hc->uuid); |
482 | dm_put(md: hc->md); |
483 | up_write(sem: &_hash_lock); |
484 | kfree(objp: new_data); |
485 | return ERR_PTR(error: -EINVAL); |
486 | } |
487 | |
488 | if (change_uuid) |
489 | __set_cell_uuid(hc, new_uuid: new_data); |
490 | else |
491 | old_name = __change_cell_name(hc, new_name: new_data); |
492 | |
493 | /* |
494 | * Wake up any dm event waiters. |
495 | */ |
496 | table = dm_get_live_table(md: hc->md, srcu_idx: &srcu_idx); |
497 | if (table) |
498 | dm_table_event(t: table); |
499 | dm_put_live_table(md: hc->md, srcu_idx); |
500 | |
501 | if (!dm_kobject_uevent(md: hc->md, action: KOBJ_CHANGE, cookie: param->event_nr, need_resize_uevent: false)) |
502 | param->flags |= DM_UEVENT_GENERATED_FLAG; |
503 | |
504 | md = hc->md; |
505 | |
506 | dm_ima_measure_on_device_rename(md); |
507 | |
508 | up_write(sem: &_hash_lock); |
509 | kfree(objp: old_name); |
510 | |
511 | return md; |
512 | } |
513 | |
514 | void dm_deferred_remove(void) |
515 | { |
516 | dm_hash_remove_all(keep_open_devices: true, mark_deferred: false, only_deferred: true); |
517 | } |
518 | |
519 | /* |
520 | *--------------------------------------------------------------- |
521 | * Implementation of the ioctl commands |
522 | *--------------------------------------------------------------- |
523 | */ |
524 | /* |
525 | * All the ioctl commands get dispatched to functions with this |
526 | * prototype. |
527 | */ |
528 | typedef int (*ioctl_fn)(struct file *filp, struct dm_ioctl *param, size_t param_size); |
529 | |
530 | static int remove_all(struct file *filp, struct dm_ioctl *param, size_t param_size) |
531 | { |
532 | dm_hash_remove_all(keep_open_devices: true, mark_deferred: !!(param->flags & DM_DEFERRED_REMOVE), only_deferred: false); |
533 | param->data_size = 0; |
534 | return 0; |
535 | } |
536 | |
537 | /* |
538 | * Round up the ptr to an 8-byte boundary. |
539 | */ |
540 | #define ALIGN_MASK 7 |
541 | static inline size_t align_val(size_t val) |
542 | { |
543 | return (val + ALIGN_MASK) & ~ALIGN_MASK; |
544 | } |
545 | static inline void *align_ptr(void *ptr) |
546 | { |
547 | return (void *)align_val(val: (size_t)ptr); |
548 | } |
549 | |
550 | /* |
551 | * Retrieves the data payload buffer from an already allocated |
552 | * struct dm_ioctl. |
553 | */ |
554 | static void *get_result_buffer(struct dm_ioctl *param, size_t param_size, |
555 | size_t *len) |
556 | { |
557 | param->data_start = align_ptr(ptr: param + 1) - (void *) param; |
558 | |
559 | if (param->data_start < param_size) |
560 | *len = param_size - param->data_start; |
561 | else |
562 | *len = 0; |
563 | |
564 | return ((void *) param) + param->data_start; |
565 | } |
566 | |
567 | static bool filter_device(struct hash_cell *hc, const char *pfx_name, const char *pfx_uuid) |
568 | { |
569 | const char *val; |
570 | size_t val_len, pfx_len; |
571 | |
572 | val = hc->name; |
573 | val_len = strlen(val); |
574 | pfx_len = strnlen(p: pfx_name, DM_NAME_LEN); |
575 | if (pfx_len > val_len) |
576 | return false; |
577 | if (memcmp(p: val, q: pfx_name, size: pfx_len)) |
578 | return false; |
579 | |
580 | val = hc->uuid ? hc->uuid : "" ; |
581 | val_len = strlen(val); |
582 | pfx_len = strnlen(p: pfx_uuid, DM_UUID_LEN); |
583 | if (pfx_len > val_len) |
584 | return false; |
585 | if (memcmp(p: val, q: pfx_uuid, size: pfx_len)) |
586 | return false; |
587 | |
588 | return true; |
589 | } |
590 | |
591 | static int list_devices(struct file *filp, struct dm_ioctl *param, size_t param_size) |
592 | { |
593 | struct rb_node *n; |
594 | struct hash_cell *hc; |
595 | size_t len, needed = 0; |
596 | struct gendisk *disk; |
597 | struct dm_name_list *orig_nl, *nl, *old_nl = NULL; |
598 | uint32_t *event_nr; |
599 | |
600 | down_write(sem: &_hash_lock); |
601 | |
602 | /* |
603 | * Loop through all the devices working out how much |
604 | * space we need. |
605 | */ |
606 | for (n = rb_first(&name_rb_tree); n; n = rb_next(n)) { |
607 | hc = container_of(n, struct hash_cell, name_node); |
608 | if (!filter_device(hc, pfx_name: param->name, pfx_uuid: param->uuid)) |
609 | continue; |
610 | needed += align_val(offsetof(struct dm_name_list, name) + strlen(hc->name) + 1); |
611 | needed += align_val(val: sizeof(uint32_t) * 2); |
612 | if (param->flags & DM_UUID_FLAG && hc->uuid) |
613 | needed += align_val(strlen(hc->uuid) + 1); |
614 | } |
615 | |
616 | /* |
617 | * Grab our output buffer. |
618 | */ |
619 | nl = orig_nl = get_result_buffer(param, param_size, len: &len); |
620 | if (len < needed || len < sizeof(nl->dev)) { |
621 | param->flags |= DM_BUFFER_FULL_FLAG; |
622 | goto out; |
623 | } |
624 | param->data_size = param->data_start + needed; |
625 | |
626 | nl->dev = 0; /* Flags no data */ |
627 | |
628 | /* |
629 | * Now loop through filling out the names. |
630 | */ |
631 | for (n = rb_first(&name_rb_tree); n; n = rb_next(n)) { |
632 | void *uuid_ptr; |
633 | |
634 | hc = container_of(n, struct hash_cell, name_node); |
635 | if (!filter_device(hc, pfx_name: param->name, pfx_uuid: param->uuid)) |
636 | continue; |
637 | if (old_nl) |
638 | old_nl->next = (uint32_t) ((void *) nl - |
639 | (void *) old_nl); |
640 | disk = dm_disk(md: hc->md); |
641 | nl->dev = huge_encode_dev(dev: disk_devt(disk)); |
642 | nl->next = 0; |
643 | strcpy(p: nl->name, q: hc->name); |
644 | |
645 | old_nl = nl; |
646 | event_nr = align_ptr(ptr: nl->name + strlen(hc->name) + 1); |
647 | event_nr[0] = dm_get_event_nr(md: hc->md); |
648 | event_nr[1] = 0; |
649 | uuid_ptr = align_ptr(ptr: event_nr + 2); |
650 | if (param->flags & DM_UUID_FLAG) { |
651 | if (hc->uuid) { |
652 | event_nr[1] |= DM_NAME_LIST_FLAG_HAS_UUID; |
653 | strcpy(p: uuid_ptr, q: hc->uuid); |
654 | uuid_ptr = align_ptr(ptr: uuid_ptr + strlen(hc->uuid) + 1); |
655 | } else { |
656 | event_nr[1] |= DM_NAME_LIST_FLAG_DOESNT_HAVE_UUID; |
657 | } |
658 | } |
659 | nl = uuid_ptr; |
660 | } |
661 | /* |
662 | * If mismatch happens, security may be compromised due to buffer |
663 | * overflow, so it's better to crash. |
664 | */ |
665 | BUG_ON((char *)nl - (char *)orig_nl != needed); |
666 | |
667 | out: |
668 | up_write(sem: &_hash_lock); |
669 | return 0; |
670 | } |
671 | |
672 | static void list_version_get_needed(struct target_type *tt, void *needed_param) |
673 | { |
674 | size_t *needed = needed_param; |
675 | |
676 | *needed += sizeof(struct dm_target_versions); |
677 | *needed += strlen(tt->name) + 1; |
678 | *needed += ALIGN_MASK; |
679 | } |
680 | |
681 | static void list_version_get_info(struct target_type *tt, void *param) |
682 | { |
683 | struct vers_iter *info = param; |
684 | |
685 | /* Check space - it might have changed since the first iteration */ |
686 | if ((char *)info->vers + sizeof(tt->version) + strlen(tt->name) + 1 > info->end) { |
687 | info->flags = DM_BUFFER_FULL_FLAG; |
688 | return; |
689 | } |
690 | |
691 | if (info->old_vers) |
692 | info->old_vers->next = (uint32_t) ((void *)info->vers - (void *)info->old_vers); |
693 | |
694 | info->vers->version[0] = tt->version[0]; |
695 | info->vers->version[1] = tt->version[1]; |
696 | info->vers->version[2] = tt->version[2]; |
697 | info->vers->next = 0; |
698 | strcpy(p: info->vers->name, q: tt->name); |
699 | |
700 | info->old_vers = info->vers; |
701 | info->vers = align_ptr(ptr: (void *)(info->vers + 1) + strlen(tt->name) + 1); |
702 | } |
703 | |
704 | static int __list_versions(struct dm_ioctl *param, size_t param_size, const char *name) |
705 | { |
706 | size_t len, needed = 0; |
707 | struct dm_target_versions *vers; |
708 | struct vers_iter iter_info; |
709 | struct target_type *tt = NULL; |
710 | |
711 | if (name) { |
712 | tt = dm_get_target_type(name); |
713 | if (!tt) |
714 | return -EINVAL; |
715 | } |
716 | |
717 | /* |
718 | * Loop through all the devices working out how much |
719 | * space we need. |
720 | */ |
721 | if (!tt) |
722 | dm_target_iterate(iter_func: list_version_get_needed, param: &needed); |
723 | else |
724 | list_version_get_needed(tt, needed_param: &needed); |
725 | |
726 | /* |
727 | * Grab our output buffer. |
728 | */ |
729 | vers = get_result_buffer(param, param_size, len: &len); |
730 | if (len < needed) { |
731 | param->flags |= DM_BUFFER_FULL_FLAG; |
732 | goto out; |
733 | } |
734 | param->data_size = param->data_start + needed; |
735 | |
736 | iter_info.param_size = param_size; |
737 | iter_info.old_vers = NULL; |
738 | iter_info.vers = vers; |
739 | iter_info.flags = 0; |
740 | iter_info.end = (char *)vers + needed; |
741 | |
742 | /* |
743 | * Now loop through filling out the names & versions. |
744 | */ |
745 | if (!tt) |
746 | dm_target_iterate(iter_func: list_version_get_info, param: &iter_info); |
747 | else |
748 | list_version_get_info(tt, param: &iter_info); |
749 | param->flags |= iter_info.flags; |
750 | |
751 | out: |
752 | if (tt) |
753 | dm_put_target_type(tt); |
754 | return 0; |
755 | } |
756 | |
757 | static int list_versions(struct file *filp, struct dm_ioctl *param, size_t param_size) |
758 | { |
759 | return __list_versions(param, param_size, NULL); |
760 | } |
761 | |
762 | static int get_target_version(struct file *filp, struct dm_ioctl *param, size_t param_size) |
763 | { |
764 | return __list_versions(param, param_size, name: param->name); |
765 | } |
766 | |
767 | static int check_name(const char *name) |
768 | { |
769 | if (strchr(name, '/')) { |
770 | DMERR("device name cannot contain '/'" ); |
771 | return -EINVAL; |
772 | } |
773 | |
774 | if (strcmp(name, DM_CONTROL_NODE) == 0 || |
775 | strcmp(name, "." ) == 0 || |
776 | strcmp(name, ".." ) == 0) { |
777 | DMERR("device name cannot be \"%s\", \".\", or \"..\"" , DM_CONTROL_NODE); |
778 | return -EINVAL; |
779 | } |
780 | |
781 | return 0; |
782 | } |
783 | |
784 | /* |
785 | * On successful return, the caller must not attempt to acquire |
786 | * _hash_lock without first calling dm_put_live_table, because dm_table_destroy |
787 | * waits for this dm_put_live_table and could be called under this lock. |
788 | */ |
789 | static struct dm_table *dm_get_inactive_table(struct mapped_device *md, int *srcu_idx) |
790 | { |
791 | struct hash_cell *hc; |
792 | struct dm_table *table = NULL; |
793 | |
794 | /* increment rcu count, we don't care about the table pointer */ |
795 | dm_get_live_table(md, srcu_idx); |
796 | |
797 | down_read(sem: &_hash_lock); |
798 | hc = dm_get_mdptr(md); |
799 | if (!hc) { |
800 | DMERR("device has been removed from the dev hash table." ); |
801 | goto out; |
802 | } |
803 | |
804 | table = hc->new_map; |
805 | |
806 | out: |
807 | up_read(sem: &_hash_lock); |
808 | |
809 | return table; |
810 | } |
811 | |
812 | static struct dm_table *dm_get_live_or_inactive_table(struct mapped_device *md, |
813 | struct dm_ioctl *param, |
814 | int *srcu_idx) |
815 | { |
816 | return (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) ? |
817 | dm_get_inactive_table(md, srcu_idx) : dm_get_live_table(md, srcu_idx); |
818 | } |
819 | |
820 | /* |
821 | * Fills in a dm_ioctl structure, ready for sending back to |
822 | * userland. |
823 | */ |
824 | static void __dev_status(struct mapped_device *md, struct dm_ioctl *param) |
825 | { |
826 | struct gendisk *disk = dm_disk(md); |
827 | struct dm_table *table; |
828 | int srcu_idx; |
829 | |
830 | param->flags &= ~(DM_SUSPEND_FLAG | DM_READONLY_FLAG | |
831 | DM_ACTIVE_PRESENT_FLAG | DM_INTERNAL_SUSPEND_FLAG); |
832 | |
833 | if (dm_suspended_md(md)) |
834 | param->flags |= DM_SUSPEND_FLAG; |
835 | |
836 | if (dm_suspended_internally_md(md)) |
837 | param->flags |= DM_INTERNAL_SUSPEND_FLAG; |
838 | |
839 | if (dm_test_deferred_remove_flag(md)) |
840 | param->flags |= DM_DEFERRED_REMOVE; |
841 | |
842 | param->dev = huge_encode_dev(dev: disk_devt(disk)); |
843 | |
844 | /* |
845 | * Yes, this will be out of date by the time it gets back |
846 | * to userland, but it is still very useful for |
847 | * debugging. |
848 | */ |
849 | param->open_count = dm_open_count(md); |
850 | |
851 | param->event_nr = dm_get_event_nr(md); |
852 | param->target_count = 0; |
853 | |
854 | table = dm_get_live_table(md, srcu_idx: &srcu_idx); |
855 | if (table) { |
856 | if (!(param->flags & DM_QUERY_INACTIVE_TABLE_FLAG)) { |
857 | if (get_disk_ro(disk)) |
858 | param->flags |= DM_READONLY_FLAG; |
859 | param->target_count = table->num_targets; |
860 | } |
861 | |
862 | param->flags |= DM_ACTIVE_PRESENT_FLAG; |
863 | } |
864 | dm_put_live_table(md, srcu_idx); |
865 | |
866 | if (param->flags & DM_QUERY_INACTIVE_TABLE_FLAG) { |
867 | int srcu_idx; |
868 | |
869 | table = dm_get_inactive_table(md, srcu_idx: &srcu_idx); |
870 | if (table) { |
871 | if (!(dm_table_get_mode(t: table) & BLK_OPEN_WRITE)) |
872 | param->flags |= DM_READONLY_FLAG; |
873 | param->target_count = table->num_targets; |
874 | } |
875 | dm_put_live_table(md, srcu_idx); |
876 | } |
877 | } |
878 | |
879 | static int dev_create(struct file *filp, struct dm_ioctl *param, size_t param_size) |
880 | { |
881 | int r, m = DM_ANY_MINOR; |
882 | struct mapped_device *md; |
883 | |
884 | r = check_name(name: param->name); |
885 | if (r) |
886 | return r; |
887 | |
888 | if (param->flags & DM_PERSISTENT_DEV_FLAG) |
889 | m = MINOR(huge_decode_dev(param->dev)); |
890 | |
891 | r = dm_create(minor: m, md: &md); |
892 | if (r) |
893 | return r; |
894 | |
895 | r = dm_hash_insert(name: param->name, uuid: *param->uuid ? param->uuid : NULL, md); |
896 | if (r) { |
897 | dm_put(md); |
898 | dm_destroy(md); |
899 | return r; |
900 | } |
901 | |
902 | param->flags &= ~DM_INACTIVE_PRESENT_FLAG; |
903 | |
904 | __dev_status(md, param); |
905 | |
906 | dm_put(md); |
907 | |
908 | return 0; |
909 | } |
910 | |
911 | /* |
912 | * Always use UUID for lookups if it's present, otherwise use name or dev. |
913 | */ |
914 | static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param) |
915 | { |
916 | struct hash_cell *hc = NULL; |
917 | |
918 | if (*param->uuid) { |
919 | if (*param->name || param->dev) { |
920 | DMERR("Invalid ioctl structure: uuid %s, name %s, dev %llx" , |
921 | param->uuid, param->name, (unsigned long long)param->dev); |
922 | return NULL; |
923 | } |
924 | |
925 | hc = __get_uuid_cell(str: param->uuid); |
926 | if (!hc) |
927 | return NULL; |
928 | } else if (*param->name) { |
929 | if (param->dev) { |
930 | DMERR("Invalid ioctl structure: name %s, dev %llx" , |
931 | param->name, (unsigned long long)param->dev); |
932 | return NULL; |
933 | } |
934 | |
935 | hc = __get_name_cell(str: param->name); |
936 | if (!hc) |
937 | return NULL; |
938 | } else if (param->dev) { |
939 | hc = __get_dev_cell(dev: param->dev); |
940 | if (!hc) |
941 | return NULL; |
942 | } else |
943 | return NULL; |
944 | |
945 | /* |
946 | * Sneakily write in both the name and the uuid |
947 | * while we have the cell. |
948 | */ |
949 | strscpy(p: param->name, q: hc->name, size: sizeof(param->name)); |
950 | if (hc->uuid) |
951 | strscpy(p: param->uuid, q: hc->uuid, size: sizeof(param->uuid)); |
952 | else |
953 | param->uuid[0] = '\0'; |
954 | |
955 | if (hc->new_map) |
956 | param->flags |= DM_INACTIVE_PRESENT_FLAG; |
957 | else |
958 | param->flags &= ~DM_INACTIVE_PRESENT_FLAG; |
959 | |
960 | return hc; |
961 | } |
962 | |
963 | static struct mapped_device *find_device(struct dm_ioctl *param) |
964 | { |
965 | struct hash_cell *hc; |
966 | struct mapped_device *md = NULL; |
967 | |
968 | down_read(sem: &_hash_lock); |
969 | hc = __find_device_hash_cell(param); |
970 | if (hc) |
971 | md = hc->md; |
972 | up_read(sem: &_hash_lock); |
973 | |
974 | return md; |
975 | } |
976 | |
977 | static int dev_remove(struct file *filp, struct dm_ioctl *param, size_t param_size) |
978 | { |
979 | struct hash_cell *hc; |
980 | struct mapped_device *md; |
981 | int r; |
982 | struct dm_table *t; |
983 | |
984 | down_write(sem: &_hash_lock); |
985 | hc = __find_device_hash_cell(param); |
986 | |
987 | if (!hc) { |
988 | DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table." ); |
989 | up_write(sem: &_hash_lock); |
990 | return -ENXIO; |
991 | } |
992 | |
993 | md = hc->md; |
994 | |
995 | /* |
996 | * Ensure the device is not open and nothing further can open it. |
997 | */ |
998 | r = dm_lock_for_deletion(md, mark_deferred: !!(param->flags & DM_DEFERRED_REMOVE), only_deferred: false); |
999 | if (r) { |
1000 | if (r == -EBUSY && param->flags & DM_DEFERRED_REMOVE) { |
1001 | up_write(sem: &_hash_lock); |
1002 | dm_put(md); |
1003 | return 0; |
1004 | } |
1005 | DMDEBUG_LIMIT("unable to remove open device %s" , hc->name); |
1006 | up_write(sem: &_hash_lock); |
1007 | dm_put(md); |
1008 | return r; |
1009 | } |
1010 | |
1011 | t = __hash_remove(hc); |
1012 | up_write(sem: &_hash_lock); |
1013 | |
1014 | if (t) { |
1015 | dm_sync_table(md); |
1016 | dm_table_destroy(t); |
1017 | } |
1018 | |
1019 | param->flags &= ~DM_DEFERRED_REMOVE; |
1020 | |
1021 | dm_ima_measure_on_device_remove(md, remove_all: false); |
1022 | |
1023 | if (!dm_kobject_uevent(md, action: KOBJ_REMOVE, cookie: param->event_nr, need_resize_uevent: false)) |
1024 | param->flags |= DM_UEVENT_GENERATED_FLAG; |
1025 | |
1026 | dm_put(md); |
1027 | dm_destroy(md); |
1028 | return 0; |
1029 | } |
1030 | |
1031 | /* |
1032 | * Check a string doesn't overrun the chunk of |
1033 | * memory we copied from userland. |
1034 | */ |
1035 | static int invalid_str(char *str, void *end) |
1036 | { |
1037 | while ((void *) str < end) |
1038 | if (!*str++) |
1039 | return 0; |
1040 | |
1041 | return -EINVAL; |
1042 | } |
1043 | |
1044 | static int dev_rename(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1045 | { |
1046 | int r; |
1047 | char *new_data = (char *) param + param->data_start; |
1048 | struct mapped_device *md; |
1049 | unsigned int change_uuid = (param->flags & DM_UUID_FLAG) ? 1 : 0; |
1050 | |
1051 | if (new_data < param->data || |
1052 | invalid_str(str: new_data, end: (void *) param + param_size) || !*new_data || |
1053 | strlen(new_data) > (change_uuid ? DM_UUID_LEN - 1 : DM_NAME_LEN - 1)) { |
1054 | DMERR("Invalid new mapped device name or uuid string supplied." ); |
1055 | return -EINVAL; |
1056 | } |
1057 | |
1058 | if (!change_uuid) { |
1059 | r = check_name(name: new_data); |
1060 | if (r) |
1061 | return r; |
1062 | } |
1063 | |
1064 | md = dm_hash_rename(param, new: new_data); |
1065 | if (IS_ERR(ptr: md)) |
1066 | return PTR_ERR(ptr: md); |
1067 | |
1068 | __dev_status(md, param); |
1069 | dm_put(md); |
1070 | |
1071 | return 0; |
1072 | } |
1073 | |
1074 | static int dev_set_geometry(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1075 | { |
1076 | int r = -EINVAL, x; |
1077 | struct mapped_device *md; |
1078 | struct hd_geometry geometry; |
1079 | unsigned long indata[4]; |
1080 | char *geostr = (char *) param + param->data_start; |
1081 | char dummy; |
1082 | |
1083 | md = find_device(param); |
1084 | if (!md) |
1085 | return -ENXIO; |
1086 | |
1087 | if (geostr < param->data || |
1088 | invalid_str(str: geostr, end: (void *) param + param_size)) { |
1089 | DMERR("Invalid geometry supplied." ); |
1090 | goto out; |
1091 | } |
1092 | |
1093 | x = sscanf(geostr, "%lu %lu %lu %lu%c" , indata, |
1094 | indata + 1, indata + 2, indata + 3, &dummy); |
1095 | |
1096 | if (x != 4) { |
1097 | DMERR("Unable to interpret geometry settings." ); |
1098 | goto out; |
1099 | } |
1100 | |
1101 | if (indata[0] > 65535 || indata[1] > 255 || indata[2] > 255) { |
1102 | DMERR("Geometry exceeds range limits." ); |
1103 | goto out; |
1104 | } |
1105 | |
1106 | geometry.cylinders = indata[0]; |
1107 | geometry.heads = indata[1]; |
1108 | geometry.sectors = indata[2]; |
1109 | geometry.start = indata[3]; |
1110 | |
1111 | r = dm_set_geometry(md, geo: &geometry); |
1112 | |
1113 | param->data_size = 0; |
1114 | |
1115 | out: |
1116 | dm_put(md); |
1117 | return r; |
1118 | } |
1119 | |
1120 | static int do_suspend(struct dm_ioctl *param) |
1121 | { |
1122 | int r = 0; |
1123 | unsigned int suspend_flags = DM_SUSPEND_LOCKFS_FLAG; |
1124 | struct mapped_device *md; |
1125 | |
1126 | md = find_device(param); |
1127 | if (!md) |
1128 | return -ENXIO; |
1129 | |
1130 | if (param->flags & DM_SKIP_LOCKFS_FLAG) |
1131 | suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG; |
1132 | if (param->flags & DM_NOFLUSH_FLAG) |
1133 | suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG; |
1134 | |
1135 | if (!dm_suspended_md(md)) { |
1136 | r = dm_suspend(md, suspend_flags); |
1137 | if (r) |
1138 | goto out; |
1139 | } |
1140 | |
1141 | __dev_status(md, param); |
1142 | |
1143 | out: |
1144 | dm_put(md); |
1145 | |
1146 | return r; |
1147 | } |
1148 | |
1149 | static int do_resume(struct dm_ioctl *param) |
1150 | { |
1151 | int r = 0; |
1152 | unsigned int suspend_flags = DM_SUSPEND_LOCKFS_FLAG; |
1153 | struct hash_cell *hc; |
1154 | struct mapped_device *md; |
1155 | struct dm_table *new_map, *old_map = NULL; |
1156 | bool need_resize_uevent = false; |
1157 | |
1158 | down_write(sem: &_hash_lock); |
1159 | |
1160 | hc = __find_device_hash_cell(param); |
1161 | if (!hc) { |
1162 | DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table." ); |
1163 | up_write(sem: &_hash_lock); |
1164 | return -ENXIO; |
1165 | } |
1166 | |
1167 | md = hc->md; |
1168 | |
1169 | new_map = hc->new_map; |
1170 | hc->new_map = NULL; |
1171 | param->flags &= ~DM_INACTIVE_PRESENT_FLAG; |
1172 | |
1173 | up_write(sem: &_hash_lock); |
1174 | |
1175 | /* Do we need to load a new map ? */ |
1176 | if (new_map) { |
1177 | sector_t old_size, new_size; |
1178 | |
1179 | /* Suspend if it isn't already suspended */ |
1180 | if (param->flags & DM_SKIP_LOCKFS_FLAG) |
1181 | suspend_flags &= ~DM_SUSPEND_LOCKFS_FLAG; |
1182 | if (param->flags & DM_NOFLUSH_FLAG) |
1183 | suspend_flags |= DM_SUSPEND_NOFLUSH_FLAG; |
1184 | if (!dm_suspended_md(md)) |
1185 | dm_suspend(md, suspend_flags); |
1186 | |
1187 | old_size = dm_get_size(md); |
1188 | old_map = dm_swap_table(md, t: new_map); |
1189 | if (IS_ERR(ptr: old_map)) { |
1190 | dm_sync_table(md); |
1191 | dm_table_destroy(t: new_map); |
1192 | dm_put(md); |
1193 | return PTR_ERR(ptr: old_map); |
1194 | } |
1195 | new_size = dm_get_size(md); |
1196 | if (old_size && new_size && old_size != new_size) |
1197 | need_resize_uevent = true; |
1198 | |
1199 | if (dm_table_get_mode(t: new_map) & BLK_OPEN_WRITE) |
1200 | set_disk_ro(disk: dm_disk(md), read_only: 0); |
1201 | else |
1202 | set_disk_ro(disk: dm_disk(md), read_only: 1); |
1203 | } |
1204 | |
1205 | if (dm_suspended_md(md)) { |
1206 | r = dm_resume(md); |
1207 | if (!r) { |
1208 | dm_ima_measure_on_device_resume(md, swap: new_map ? true : false); |
1209 | |
1210 | if (!dm_kobject_uevent(md, action: KOBJ_CHANGE, cookie: param->event_nr, need_resize_uevent)) |
1211 | param->flags |= DM_UEVENT_GENERATED_FLAG; |
1212 | } |
1213 | } |
1214 | |
1215 | /* |
1216 | * Since dm_swap_table synchronizes RCU, nobody should be in |
1217 | * read-side critical section already. |
1218 | */ |
1219 | if (old_map) |
1220 | dm_table_destroy(t: old_map); |
1221 | |
1222 | if (!r) |
1223 | __dev_status(md, param); |
1224 | |
1225 | dm_put(md); |
1226 | return r; |
1227 | } |
1228 | |
1229 | /* |
1230 | * Set or unset the suspension state of a device. |
1231 | * If the device already is in the requested state we just return its status. |
1232 | */ |
1233 | static int dev_suspend(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1234 | { |
1235 | if (param->flags & DM_SUSPEND_FLAG) |
1236 | return do_suspend(param); |
1237 | |
1238 | return do_resume(param); |
1239 | } |
1240 | |
1241 | /* |
1242 | * Copies device info back to user space, used by |
1243 | * the create and info ioctls. |
1244 | */ |
1245 | static int dev_status(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1246 | { |
1247 | struct mapped_device *md; |
1248 | |
1249 | md = find_device(param); |
1250 | if (!md) |
1251 | return -ENXIO; |
1252 | |
1253 | __dev_status(md, param); |
1254 | dm_put(md); |
1255 | |
1256 | return 0; |
1257 | } |
1258 | |
1259 | /* |
1260 | * Build up the status struct for each target |
1261 | */ |
1262 | static void retrieve_status(struct dm_table *table, |
1263 | struct dm_ioctl *param, size_t param_size) |
1264 | { |
1265 | unsigned int i, num_targets; |
1266 | struct dm_target_spec *spec; |
1267 | char *outbuf, *outptr; |
1268 | status_type_t type; |
1269 | size_t remaining, len, used = 0; |
1270 | unsigned int status_flags = 0; |
1271 | |
1272 | outptr = outbuf = get_result_buffer(param, param_size, len: &len); |
1273 | |
1274 | if (param->flags & DM_STATUS_TABLE_FLAG) |
1275 | type = STATUSTYPE_TABLE; |
1276 | else if (param->flags & DM_IMA_MEASUREMENT_FLAG) |
1277 | type = STATUSTYPE_IMA; |
1278 | else |
1279 | type = STATUSTYPE_INFO; |
1280 | |
1281 | /* Get all the target info */ |
1282 | num_targets = table->num_targets; |
1283 | for (i = 0; i < num_targets; i++) { |
1284 | struct dm_target *ti = dm_table_get_target(t: table, index: i); |
1285 | size_t l; |
1286 | |
1287 | remaining = len - (outptr - outbuf); |
1288 | if (remaining <= sizeof(struct dm_target_spec)) { |
1289 | param->flags |= DM_BUFFER_FULL_FLAG; |
1290 | break; |
1291 | } |
1292 | |
1293 | spec = (struct dm_target_spec *) outptr; |
1294 | |
1295 | spec->status = 0; |
1296 | spec->sector_start = ti->begin; |
1297 | spec->length = ti->len; |
1298 | strscpy_pad(dest: spec->target_type, src: ti->type->name, |
1299 | count: sizeof(spec->target_type)); |
1300 | |
1301 | outptr += sizeof(struct dm_target_spec); |
1302 | remaining = len - (outptr - outbuf); |
1303 | if (remaining <= 0) { |
1304 | param->flags |= DM_BUFFER_FULL_FLAG; |
1305 | break; |
1306 | } |
1307 | |
1308 | /* Get the status/table string from the target driver */ |
1309 | if (ti->type->status) { |
1310 | if (param->flags & DM_NOFLUSH_FLAG) |
1311 | status_flags |= DM_STATUS_NOFLUSH_FLAG; |
1312 | ti->type->status(ti, type, status_flags, outptr, remaining); |
1313 | } else |
1314 | outptr[0] = '\0'; |
1315 | |
1316 | l = strlen(outptr) + 1; |
1317 | if (l == remaining) { |
1318 | param->flags |= DM_BUFFER_FULL_FLAG; |
1319 | break; |
1320 | } |
1321 | |
1322 | outptr += l; |
1323 | used = param->data_start + (outptr - outbuf); |
1324 | |
1325 | outptr = align_ptr(ptr: outptr); |
1326 | spec->next = outptr - outbuf; |
1327 | } |
1328 | |
1329 | if (used) |
1330 | param->data_size = used; |
1331 | |
1332 | param->target_count = num_targets; |
1333 | } |
1334 | |
1335 | /* |
1336 | * Wait for a device to report an event |
1337 | */ |
1338 | static int dev_wait(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1339 | { |
1340 | int r = 0; |
1341 | struct mapped_device *md; |
1342 | struct dm_table *table; |
1343 | int srcu_idx; |
1344 | |
1345 | md = find_device(param); |
1346 | if (!md) |
1347 | return -ENXIO; |
1348 | |
1349 | /* |
1350 | * Wait for a notification event |
1351 | */ |
1352 | if (dm_wait_event(md, event_nr: param->event_nr)) { |
1353 | r = -ERESTARTSYS; |
1354 | goto out; |
1355 | } |
1356 | |
1357 | /* |
1358 | * The userland program is going to want to know what |
1359 | * changed to trigger the event, so we may as well tell |
1360 | * him and save an ioctl. |
1361 | */ |
1362 | __dev_status(md, param); |
1363 | |
1364 | table = dm_get_live_or_inactive_table(md, param, srcu_idx: &srcu_idx); |
1365 | if (table) |
1366 | retrieve_status(table, param, param_size); |
1367 | dm_put_live_table(md, srcu_idx); |
1368 | |
1369 | out: |
1370 | dm_put(md); |
1371 | |
1372 | return r; |
1373 | } |
1374 | |
1375 | /* |
1376 | * Remember the global event number and make it possible to poll |
1377 | * for further events. |
1378 | */ |
1379 | static int dev_arm_poll(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1380 | { |
1381 | struct dm_file *priv = filp->private_data; |
1382 | |
1383 | priv->global_event_nr = atomic_read(v: &dm_global_event_nr); |
1384 | |
1385 | return 0; |
1386 | } |
1387 | |
1388 | static inline blk_mode_t get_mode(struct dm_ioctl *param) |
1389 | { |
1390 | blk_mode_t mode = BLK_OPEN_READ | BLK_OPEN_WRITE; |
1391 | |
1392 | if (param->flags & DM_READONLY_FLAG) |
1393 | mode = BLK_OPEN_READ; |
1394 | |
1395 | return mode; |
1396 | } |
1397 | |
1398 | static int next_target(struct dm_target_spec *last, uint32_t next, const char *end, |
1399 | struct dm_target_spec **spec, char **target_params) |
1400 | { |
1401 | static_assert(__alignof__(struct dm_target_spec) <= 8, |
1402 | "struct dm_target_spec must not require more than 8-byte alignment" ); |
1403 | |
1404 | /* |
1405 | * Number of bytes remaining, starting with last. This is always |
1406 | * sizeof(struct dm_target_spec) or more, as otherwise *last was |
1407 | * out of bounds already. |
1408 | */ |
1409 | size_t remaining = end - (char *)last; |
1410 | |
1411 | /* |
1412 | * There must be room for both the next target spec and the |
1413 | * NUL-terminator of the target itself. |
1414 | */ |
1415 | if (remaining - sizeof(struct dm_target_spec) <= next) { |
1416 | DMERR("Target spec extends beyond end of parameters" ); |
1417 | return -EINVAL; |
1418 | } |
1419 | |
1420 | if (next % __alignof__(struct dm_target_spec)) { |
1421 | DMERR("Next dm_target_spec (offset %u) is not %zu-byte aligned" , |
1422 | next, __alignof__(struct dm_target_spec)); |
1423 | return -EINVAL; |
1424 | } |
1425 | |
1426 | *spec = (struct dm_target_spec *) ((unsigned char *) last + next); |
1427 | *target_params = (char *) (*spec + 1); |
1428 | |
1429 | return 0; |
1430 | } |
1431 | |
1432 | static int populate_table(struct dm_table *table, |
1433 | struct dm_ioctl *param, size_t param_size) |
1434 | { |
1435 | int r; |
1436 | unsigned int i = 0; |
1437 | struct dm_target_spec *spec = (struct dm_target_spec *) param; |
1438 | uint32_t next = param->data_start; |
1439 | const char *const end = (const char *) param + param_size; |
1440 | char *target_params; |
1441 | size_t min_size = sizeof(struct dm_ioctl); |
1442 | |
1443 | if (!param->target_count) { |
1444 | DMERR("%s: no targets specified" , __func__); |
1445 | return -EINVAL; |
1446 | } |
1447 | |
1448 | for (i = 0; i < param->target_count; i++) { |
1449 | const char *nul_terminator; |
1450 | |
1451 | if (next < min_size) { |
1452 | DMERR("%s: next target spec (offset %u) overlaps %s" , |
1453 | __func__, next, i ? "previous target" : "'struct dm_ioctl'" ); |
1454 | return -EINVAL; |
1455 | } |
1456 | |
1457 | r = next_target(last: spec, next, end, spec: &spec, target_params: &target_params); |
1458 | if (r) { |
1459 | DMERR("unable to find target" ); |
1460 | return r; |
1461 | } |
1462 | |
1463 | nul_terminator = memchr(p: target_params, c: 0, size: (size_t)(end - target_params)); |
1464 | if (nul_terminator == NULL) { |
1465 | DMERR("%s: target parameters not NUL-terminated" , __func__); |
1466 | return -EINVAL; |
1467 | } |
1468 | |
1469 | /* Add 1 for NUL terminator */ |
1470 | min_size = (size_t)(nul_terminator - (const char *)spec) + 1; |
1471 | |
1472 | r = dm_table_add_target(t: table, type: spec->target_type, |
1473 | start: (sector_t) spec->sector_start, |
1474 | len: (sector_t) spec->length, |
1475 | params: target_params); |
1476 | if (r) { |
1477 | DMERR("error adding target to table" ); |
1478 | return r; |
1479 | } |
1480 | |
1481 | next = spec->next; |
1482 | } |
1483 | |
1484 | return dm_table_complete(t: table); |
1485 | } |
1486 | |
1487 | static bool is_valid_type(enum dm_queue_mode cur, enum dm_queue_mode new) |
1488 | { |
1489 | if (cur == new || |
1490 | (cur == DM_TYPE_BIO_BASED && new == DM_TYPE_DAX_BIO_BASED)) |
1491 | return true; |
1492 | |
1493 | return false; |
1494 | } |
1495 | |
1496 | static int table_load(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1497 | { |
1498 | int r; |
1499 | struct hash_cell *hc; |
1500 | struct dm_table *t, *old_map = NULL; |
1501 | struct mapped_device *md; |
1502 | struct target_type *immutable_target_type; |
1503 | |
1504 | md = find_device(param); |
1505 | if (!md) |
1506 | return -ENXIO; |
1507 | |
1508 | r = dm_table_create(result: &t, mode: get_mode(param), num_targets: param->target_count, md); |
1509 | if (r) |
1510 | goto err; |
1511 | |
1512 | /* Protect md->type and md->queue against concurrent table loads. */ |
1513 | dm_lock_md_type(md); |
1514 | r = populate_table(table: t, param, param_size); |
1515 | if (r) |
1516 | goto err_unlock_md_type; |
1517 | |
1518 | dm_ima_measure_on_table_load(table: t, status_flags: STATUSTYPE_IMA); |
1519 | |
1520 | immutable_target_type = dm_get_immutable_target_type(md); |
1521 | if (immutable_target_type && |
1522 | (immutable_target_type != dm_table_get_immutable_target_type(t)) && |
1523 | !dm_table_get_wildcard_target(t)) { |
1524 | DMERR("can't replace immutable target type %s" , |
1525 | immutable_target_type->name); |
1526 | r = -EINVAL; |
1527 | goto err_unlock_md_type; |
1528 | } |
1529 | |
1530 | if (dm_get_md_type(md) == DM_TYPE_NONE) { |
1531 | /* setup md->queue to reflect md's type (may block) */ |
1532 | r = dm_setup_md_queue(md, t); |
1533 | if (r) { |
1534 | DMERR("unable to set up device queue for new table." ); |
1535 | goto err_unlock_md_type; |
1536 | } |
1537 | } else if (!is_valid_type(cur: dm_get_md_type(md), new: dm_table_get_type(t))) { |
1538 | DMERR("can't change device type (old=%u vs new=%u) after initial table load." , |
1539 | dm_get_md_type(md), dm_table_get_type(t)); |
1540 | r = -EINVAL; |
1541 | goto err_unlock_md_type; |
1542 | } |
1543 | |
1544 | dm_unlock_md_type(md); |
1545 | |
1546 | /* stage inactive table */ |
1547 | down_write(sem: &_hash_lock); |
1548 | hc = dm_get_mdptr(md); |
1549 | if (!hc) { |
1550 | DMERR("device has been removed from the dev hash table." ); |
1551 | up_write(sem: &_hash_lock); |
1552 | r = -ENXIO; |
1553 | goto err_destroy_table; |
1554 | } |
1555 | |
1556 | if (hc->new_map) |
1557 | old_map = hc->new_map; |
1558 | hc->new_map = t; |
1559 | up_write(sem: &_hash_lock); |
1560 | |
1561 | param->flags |= DM_INACTIVE_PRESENT_FLAG; |
1562 | __dev_status(md, param); |
1563 | |
1564 | if (old_map) { |
1565 | dm_sync_table(md); |
1566 | dm_table_destroy(t: old_map); |
1567 | } |
1568 | |
1569 | dm_put(md); |
1570 | |
1571 | return 0; |
1572 | |
1573 | err_unlock_md_type: |
1574 | dm_unlock_md_type(md); |
1575 | err_destroy_table: |
1576 | dm_table_destroy(t); |
1577 | err: |
1578 | dm_put(md); |
1579 | |
1580 | return r; |
1581 | } |
1582 | |
1583 | static int table_clear(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1584 | { |
1585 | struct hash_cell *hc; |
1586 | struct mapped_device *md; |
1587 | struct dm_table *old_map = NULL; |
1588 | bool has_new_map = false; |
1589 | |
1590 | down_write(sem: &_hash_lock); |
1591 | |
1592 | hc = __find_device_hash_cell(param); |
1593 | if (!hc) { |
1594 | DMDEBUG_LIMIT("device doesn't appear to be in the dev hash table." ); |
1595 | up_write(sem: &_hash_lock); |
1596 | return -ENXIO; |
1597 | } |
1598 | |
1599 | if (hc->new_map) { |
1600 | old_map = hc->new_map; |
1601 | hc->new_map = NULL; |
1602 | has_new_map = true; |
1603 | } |
1604 | |
1605 | md = hc->md; |
1606 | up_write(sem: &_hash_lock); |
1607 | |
1608 | param->flags &= ~DM_INACTIVE_PRESENT_FLAG; |
1609 | __dev_status(md, param); |
1610 | |
1611 | if (old_map) { |
1612 | dm_sync_table(md); |
1613 | dm_table_destroy(t: old_map); |
1614 | } |
1615 | dm_ima_measure_on_table_clear(md, new_map: has_new_map); |
1616 | dm_put(md); |
1617 | |
1618 | return 0; |
1619 | } |
1620 | |
1621 | /* |
1622 | * Retrieves a list of devices used by a particular dm device. |
1623 | */ |
1624 | static void retrieve_deps(struct dm_table *table, |
1625 | struct dm_ioctl *param, size_t param_size) |
1626 | { |
1627 | unsigned int count = 0; |
1628 | struct list_head *tmp; |
1629 | size_t len, needed; |
1630 | struct dm_dev_internal *dd; |
1631 | struct dm_target_deps *deps; |
1632 | |
1633 | down_read(sem: &table->devices_lock); |
1634 | |
1635 | deps = get_result_buffer(param, param_size, len: &len); |
1636 | |
1637 | /* |
1638 | * Count the devices. |
1639 | */ |
1640 | list_for_each(tmp, dm_table_get_devices(table)) |
1641 | count++; |
1642 | |
1643 | /* |
1644 | * Check we have enough space. |
1645 | */ |
1646 | needed = struct_size(deps, dev, count); |
1647 | if (len < needed) { |
1648 | param->flags |= DM_BUFFER_FULL_FLAG; |
1649 | goto out; |
1650 | } |
1651 | |
1652 | /* |
1653 | * Fill in the devices. |
1654 | */ |
1655 | deps->count = count; |
1656 | count = 0; |
1657 | list_for_each_entry(dd, dm_table_get_devices(table), list) |
1658 | deps->dev[count++] = huge_encode_dev(dev: dd->dm_dev->bdev->bd_dev); |
1659 | |
1660 | param->data_size = param->data_start + needed; |
1661 | |
1662 | out: |
1663 | up_read(sem: &table->devices_lock); |
1664 | } |
1665 | |
1666 | static int table_deps(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1667 | { |
1668 | struct mapped_device *md; |
1669 | struct dm_table *table; |
1670 | int srcu_idx; |
1671 | |
1672 | md = find_device(param); |
1673 | if (!md) |
1674 | return -ENXIO; |
1675 | |
1676 | __dev_status(md, param); |
1677 | |
1678 | table = dm_get_live_or_inactive_table(md, param, srcu_idx: &srcu_idx); |
1679 | if (table) |
1680 | retrieve_deps(table, param, param_size); |
1681 | dm_put_live_table(md, srcu_idx); |
1682 | |
1683 | dm_put(md); |
1684 | |
1685 | return 0; |
1686 | } |
1687 | |
1688 | /* |
1689 | * Return the status of a device as a text string for each |
1690 | * target. |
1691 | */ |
1692 | static int table_status(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1693 | { |
1694 | struct mapped_device *md; |
1695 | struct dm_table *table; |
1696 | int srcu_idx; |
1697 | |
1698 | md = find_device(param); |
1699 | if (!md) |
1700 | return -ENXIO; |
1701 | |
1702 | __dev_status(md, param); |
1703 | |
1704 | table = dm_get_live_or_inactive_table(md, param, srcu_idx: &srcu_idx); |
1705 | if (table) |
1706 | retrieve_status(table, param, param_size); |
1707 | dm_put_live_table(md, srcu_idx); |
1708 | |
1709 | dm_put(md); |
1710 | |
1711 | return 0; |
1712 | } |
1713 | |
1714 | /* |
1715 | * Process device-mapper dependent messages. Messages prefixed with '@' |
1716 | * are processed by the DM core. All others are delivered to the target. |
1717 | * Returns a number <= 1 if message was processed by device mapper. |
1718 | * Returns 2 if message should be delivered to the target. |
1719 | */ |
1720 | static int message_for_md(struct mapped_device *md, unsigned int argc, char **argv, |
1721 | char *result, unsigned int maxlen) |
1722 | { |
1723 | int r; |
1724 | |
1725 | if (**argv != '@') |
1726 | return 2; /* no '@' prefix, deliver to target */ |
1727 | |
1728 | if (!strcasecmp(s1: argv[0], s2: "@cancel_deferred_remove" )) { |
1729 | if (argc != 1) { |
1730 | DMERR("Invalid arguments for @cancel_deferred_remove" ); |
1731 | return -EINVAL; |
1732 | } |
1733 | return dm_cancel_deferred_remove(md); |
1734 | } |
1735 | |
1736 | r = dm_stats_message(md, argc, argv, result, maxlen); |
1737 | if (r < 2) |
1738 | return r; |
1739 | |
1740 | DMERR("Unsupported message sent to DM core: %s" , argv[0]); |
1741 | return -EINVAL; |
1742 | } |
1743 | |
1744 | /* |
1745 | * Pass a message to the target that's at the supplied device offset. |
1746 | */ |
1747 | static int target_message(struct file *filp, struct dm_ioctl *param, size_t param_size) |
1748 | { |
1749 | int r, argc; |
1750 | char **argv; |
1751 | struct mapped_device *md; |
1752 | struct dm_table *table; |
1753 | struct dm_target *ti; |
1754 | struct dm_target_msg *tmsg = (void *) param + param->data_start; |
1755 | size_t maxlen; |
1756 | char *result = get_result_buffer(param, param_size, len: &maxlen); |
1757 | int srcu_idx; |
1758 | |
1759 | md = find_device(param); |
1760 | if (!md) |
1761 | return -ENXIO; |
1762 | |
1763 | if (tmsg < (struct dm_target_msg *) param->data || |
1764 | invalid_str(str: tmsg->message, end: (void *) param + param_size)) { |
1765 | DMERR("Invalid target message parameters." ); |
1766 | r = -EINVAL; |
1767 | goto out; |
1768 | } |
1769 | |
1770 | r = dm_split_args(argc: &argc, argvp: &argv, input: tmsg->message); |
1771 | if (r) { |
1772 | DMERR("Failed to split target message parameters" ); |
1773 | goto out; |
1774 | } |
1775 | |
1776 | if (!argc) { |
1777 | DMERR("Empty message received." ); |
1778 | r = -EINVAL; |
1779 | goto out_argv; |
1780 | } |
1781 | |
1782 | r = message_for_md(md, argc, argv, result, maxlen); |
1783 | if (r <= 1) |
1784 | goto out_argv; |
1785 | |
1786 | table = dm_get_live_table(md, srcu_idx: &srcu_idx); |
1787 | if (!table) |
1788 | goto out_table; |
1789 | |
1790 | if (dm_deleting_md(md)) { |
1791 | r = -ENXIO; |
1792 | goto out_table; |
1793 | } |
1794 | |
1795 | ti = dm_table_find_target(t: table, sector: tmsg->sector); |
1796 | if (!ti) { |
1797 | DMERR("Target message sector outside device." ); |
1798 | r = -EINVAL; |
1799 | } else if (ti->type->message) |
1800 | r = ti->type->message(ti, argc, argv, result, maxlen); |
1801 | else { |
1802 | DMERR("Target type does not support messages" ); |
1803 | r = -EINVAL; |
1804 | } |
1805 | |
1806 | out_table: |
1807 | dm_put_live_table(md, srcu_idx); |
1808 | out_argv: |
1809 | kfree(objp: argv); |
1810 | out: |
1811 | if (r >= 0) |
1812 | __dev_status(md, param); |
1813 | |
1814 | if (r == 1) { |
1815 | param->flags |= DM_DATA_OUT_FLAG; |
1816 | if (dm_message_test_buffer_overflow(result, maxlen)) |
1817 | param->flags |= DM_BUFFER_FULL_FLAG; |
1818 | else |
1819 | param->data_size = param->data_start + strlen(result) + 1; |
1820 | r = 0; |
1821 | } |
1822 | |
1823 | dm_put(md); |
1824 | return r; |
1825 | } |
1826 | |
1827 | /* |
1828 | * The ioctl parameter block consists of two parts, a dm_ioctl struct |
1829 | * followed by a data buffer. This flag is set if the second part, |
1830 | * which has a variable size, is not used by the function processing |
1831 | * the ioctl. |
1832 | */ |
1833 | #define IOCTL_FLAGS_NO_PARAMS 1 |
1834 | #define IOCTL_FLAGS_ISSUE_GLOBAL_EVENT 2 |
1835 | |
1836 | /* |
1837 | *--------------------------------------------------------------- |
1838 | * Implementation of open/close/ioctl on the special char device. |
1839 | *--------------------------------------------------------------- |
1840 | */ |
1841 | static ioctl_fn lookup_ioctl(unsigned int cmd, int *ioctl_flags) |
1842 | { |
1843 | static const struct { |
1844 | int cmd; |
1845 | int flags; |
1846 | ioctl_fn fn; |
1847 | } _ioctls[] = { |
1848 | {DM_VERSION_CMD, 0, NULL}, /* version is dealt with elsewhere */ |
1849 | {DM_REMOVE_ALL_CMD, IOCTL_FLAGS_NO_PARAMS | IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, remove_all}, |
1850 | {DM_LIST_DEVICES_CMD, 0, list_devices}, |
1851 | |
1852 | {DM_DEV_CREATE_CMD, IOCTL_FLAGS_NO_PARAMS | IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, dev_create}, |
1853 | {DM_DEV_REMOVE_CMD, IOCTL_FLAGS_NO_PARAMS | IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, dev_remove}, |
1854 | {DM_DEV_RENAME_CMD, IOCTL_FLAGS_ISSUE_GLOBAL_EVENT, dev_rename}, |
1855 | {DM_DEV_SUSPEND_CMD, IOCTL_FLAGS_NO_PARAMS, dev_suspend}, |
1856 | {DM_DEV_STATUS_CMD, IOCTL_FLAGS_NO_PARAMS, dev_status}, |
1857 | {DM_DEV_WAIT_CMD, 0, dev_wait}, |
1858 | |
1859 | {DM_TABLE_LOAD_CMD, 0, table_load}, |
1860 | {DM_TABLE_CLEAR_CMD, IOCTL_FLAGS_NO_PARAMS, table_clear}, |
1861 | {DM_TABLE_DEPS_CMD, 0, table_deps}, |
1862 | {DM_TABLE_STATUS_CMD, 0, table_status}, |
1863 | |
1864 | {DM_LIST_VERSIONS_CMD, 0, list_versions}, |
1865 | |
1866 | {DM_TARGET_MSG_CMD, 0, target_message}, |
1867 | {DM_DEV_SET_GEOMETRY_CMD, 0, dev_set_geometry}, |
1868 | {DM_DEV_ARM_POLL_CMD, IOCTL_FLAGS_NO_PARAMS, dev_arm_poll}, |
1869 | {DM_GET_TARGET_VERSION_CMD, 0, get_target_version}, |
1870 | }; |
1871 | |
1872 | if (unlikely(cmd >= ARRAY_SIZE(_ioctls))) |
1873 | return NULL; |
1874 | |
1875 | cmd = array_index_nospec(cmd, ARRAY_SIZE(_ioctls)); |
1876 | *ioctl_flags = _ioctls[cmd].flags; |
1877 | return _ioctls[cmd].fn; |
1878 | } |
1879 | |
1880 | /* |
1881 | * As well as checking the version compatibility this always |
1882 | * copies the kernel interface version out. |
1883 | */ |
1884 | static int check_version(unsigned int cmd, struct dm_ioctl __user *user, |
1885 | struct dm_ioctl *kernel_params) |
1886 | { |
1887 | int r = 0; |
1888 | |
1889 | /* Make certain version is first member of dm_ioctl struct */ |
1890 | BUILD_BUG_ON(offsetof(struct dm_ioctl, version) != 0); |
1891 | |
1892 | if (copy_from_user(to: kernel_params->version, from: user->version, n: sizeof(kernel_params->version))) |
1893 | return -EFAULT; |
1894 | |
1895 | if ((kernel_params->version[0] != DM_VERSION_MAJOR) || |
1896 | (kernel_params->version[1] > DM_VERSION_MINOR)) { |
1897 | DMERR("ioctl interface mismatch: kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)" , |
1898 | DM_VERSION_MAJOR, DM_VERSION_MINOR, |
1899 | DM_VERSION_PATCHLEVEL, |
1900 | kernel_params->version[0], |
1901 | kernel_params->version[1], |
1902 | kernel_params->version[2], |
1903 | cmd); |
1904 | r = -EINVAL; |
1905 | } |
1906 | |
1907 | /* |
1908 | * Fill in the kernel version. |
1909 | */ |
1910 | kernel_params->version[0] = DM_VERSION_MAJOR; |
1911 | kernel_params->version[1] = DM_VERSION_MINOR; |
1912 | kernel_params->version[2] = DM_VERSION_PATCHLEVEL; |
1913 | if (copy_to_user(to: user->version, from: kernel_params->version, n: sizeof(kernel_params->version))) |
1914 | return -EFAULT; |
1915 | |
1916 | return r; |
1917 | } |
1918 | |
1919 | #define DM_PARAMS_MALLOC 0x0001 /* Params allocated with kvmalloc() */ |
1920 | #define DM_WIPE_BUFFER 0x0010 /* Wipe input buffer before returning from ioctl */ |
1921 | |
1922 | static void free_params(struct dm_ioctl *param, size_t param_size, int param_flags) |
1923 | { |
1924 | if (param_flags & DM_WIPE_BUFFER) |
1925 | memset(param, 0, param_size); |
1926 | |
1927 | if (param_flags & DM_PARAMS_MALLOC) |
1928 | kvfree(addr: param); |
1929 | } |
1930 | |
1931 | static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl *param_kernel, |
1932 | int ioctl_flags, struct dm_ioctl **param, int *param_flags) |
1933 | { |
1934 | struct dm_ioctl *dmi; |
1935 | int secure_data; |
1936 | const size_t minimum_data_size = offsetof(struct dm_ioctl, data); |
1937 | |
1938 | /* check_version() already copied version from userspace, avoid TOCTOU */ |
1939 | if (copy_from_user(to: (char *)param_kernel + sizeof(param_kernel->version), |
1940 | from: (char __user *)user + sizeof(param_kernel->version), |
1941 | n: minimum_data_size - sizeof(param_kernel->version))) |
1942 | return -EFAULT; |
1943 | |
1944 | if (param_kernel->data_size < minimum_data_size) { |
1945 | DMERR("Invalid data size in the ioctl structure: %u" , |
1946 | param_kernel->data_size); |
1947 | return -EINVAL; |
1948 | } |
1949 | |
1950 | secure_data = param_kernel->flags & DM_SECURE_DATA_FLAG; |
1951 | |
1952 | *param_flags = secure_data ? DM_WIPE_BUFFER : 0; |
1953 | |
1954 | if (ioctl_flags & IOCTL_FLAGS_NO_PARAMS) { |
1955 | dmi = param_kernel; |
1956 | dmi->data_size = minimum_data_size; |
1957 | goto data_copied; |
1958 | } |
1959 | |
1960 | /* |
1961 | * Use __GFP_HIGH to avoid low memory issues when a device is |
1962 | * suspended and the ioctl is needed to resume it. |
1963 | * Use kmalloc() rather than vmalloc() when we can. |
1964 | */ |
1965 | dmi = NULL; |
1966 | dmi = kvmalloc(size: param_kernel->data_size, GFP_NOIO | __GFP_HIGH); |
1967 | |
1968 | if (!dmi) { |
1969 | if (secure_data && clear_user(to: user, n: param_kernel->data_size)) |
1970 | return -EFAULT; |
1971 | return -ENOMEM; |
1972 | } |
1973 | |
1974 | *param_flags |= DM_PARAMS_MALLOC; |
1975 | |
1976 | /* Copy from param_kernel (which was already copied from user) */ |
1977 | memcpy(dmi, param_kernel, minimum_data_size); |
1978 | |
1979 | if (copy_from_user(to: &dmi->data, from: (char __user *)user + minimum_data_size, |
1980 | n: param_kernel->data_size - minimum_data_size)) |
1981 | goto bad; |
1982 | data_copied: |
1983 | /* Wipe the user buffer so we do not return it to userspace */ |
1984 | if (secure_data && clear_user(to: user, n: param_kernel->data_size)) |
1985 | goto bad; |
1986 | |
1987 | *param = dmi; |
1988 | return 0; |
1989 | |
1990 | bad: |
1991 | free_params(param: dmi, param_size: param_kernel->data_size, param_flags: *param_flags); |
1992 | |
1993 | return -EFAULT; |
1994 | } |
1995 | |
1996 | static int validate_params(uint cmd, struct dm_ioctl *param) |
1997 | { |
1998 | /* Always clear this flag */ |
1999 | param->flags &= ~DM_BUFFER_FULL_FLAG; |
2000 | param->flags &= ~DM_UEVENT_GENERATED_FLAG; |
2001 | param->flags &= ~DM_SECURE_DATA_FLAG; |
2002 | param->flags &= ~DM_DATA_OUT_FLAG; |
2003 | |
2004 | /* Ignores parameters */ |
2005 | if (cmd == DM_REMOVE_ALL_CMD || |
2006 | cmd == DM_LIST_DEVICES_CMD || |
2007 | cmd == DM_LIST_VERSIONS_CMD) |
2008 | return 0; |
2009 | |
2010 | if (cmd == DM_DEV_CREATE_CMD) { |
2011 | if (!*param->name) { |
2012 | DMERR("name not supplied when creating device" ); |
2013 | return -EINVAL; |
2014 | } |
2015 | } else if (*param->uuid && *param->name) { |
2016 | DMERR("only supply one of name or uuid, cmd(%u)" , cmd); |
2017 | return -EINVAL; |
2018 | } |
2019 | |
2020 | /* Ensure strings are terminated */ |
2021 | param->name[DM_NAME_LEN - 1] = '\0'; |
2022 | param->uuid[DM_UUID_LEN - 1] = '\0'; |
2023 | |
2024 | return 0; |
2025 | } |
2026 | |
2027 | static int ctl_ioctl(struct file *file, uint command, struct dm_ioctl __user *user) |
2028 | { |
2029 | int r = 0; |
2030 | int ioctl_flags; |
2031 | int param_flags; |
2032 | unsigned int cmd; |
2033 | struct dm_ioctl *param; |
2034 | ioctl_fn fn = NULL; |
2035 | size_t input_param_size; |
2036 | struct dm_ioctl param_kernel; |
2037 | |
2038 | /* only root can play with this */ |
2039 | if (!capable(CAP_SYS_ADMIN)) |
2040 | return -EACCES; |
2041 | |
2042 | if (_IOC_TYPE(command) != DM_IOCTL) |
2043 | return -ENOTTY; |
2044 | |
2045 | cmd = _IOC_NR(command); |
2046 | |
2047 | /* |
2048 | * Check the interface version passed in. This also |
2049 | * writes out the kernel's interface version. |
2050 | */ |
2051 | r = check_version(cmd, user, kernel_params: ¶m_kernel); |
2052 | if (r) |
2053 | return r; |
2054 | |
2055 | /* |
2056 | * Nothing more to do for the version command. |
2057 | */ |
2058 | if (cmd == DM_VERSION_CMD) |
2059 | return 0; |
2060 | |
2061 | fn = lookup_ioctl(cmd, ioctl_flags: &ioctl_flags); |
2062 | if (!fn) { |
2063 | DMERR("dm_ctl_ioctl: unknown command 0x%x" , command); |
2064 | return -ENOTTY; |
2065 | } |
2066 | |
2067 | /* |
2068 | * Copy the parameters into kernel space. |
2069 | */ |
2070 | r = copy_params(user, param_kernel: ¶m_kernel, ioctl_flags, param: ¶m, param_flags: ¶m_flags); |
2071 | |
2072 | if (r) |
2073 | return r; |
2074 | |
2075 | input_param_size = param->data_size; |
2076 | r = validate_params(cmd, param); |
2077 | if (r) |
2078 | goto out; |
2079 | |
2080 | param->data_size = offsetof(struct dm_ioctl, data); |
2081 | r = fn(file, param, input_param_size); |
2082 | |
2083 | if (unlikely(param->flags & DM_BUFFER_FULL_FLAG) && |
2084 | unlikely(ioctl_flags & IOCTL_FLAGS_NO_PARAMS)) |
2085 | DMERR("ioctl %d tried to output some data but has IOCTL_FLAGS_NO_PARAMS set" , cmd); |
2086 | |
2087 | if (!r && ioctl_flags & IOCTL_FLAGS_ISSUE_GLOBAL_EVENT) |
2088 | dm_issue_global_event(); |
2089 | |
2090 | /* |
2091 | * Copy the results back to userland. |
2092 | */ |
2093 | if (!r && copy_to_user(to: user, from: param, n: param->data_size)) |
2094 | r = -EFAULT; |
2095 | |
2096 | out: |
2097 | free_params(param, param_size: input_param_size, param_flags); |
2098 | return r; |
2099 | } |
2100 | |
2101 | static long dm_ctl_ioctl(struct file *file, uint command, ulong u) |
2102 | { |
2103 | return (long)ctl_ioctl(file, command, user: (struct dm_ioctl __user *)u); |
2104 | } |
2105 | |
2106 | #ifdef CONFIG_COMPAT |
2107 | static long dm_compat_ctl_ioctl(struct file *file, uint command, ulong u) |
2108 | { |
2109 | return (long)dm_ctl_ioctl(file, command, u: (ulong) compat_ptr(uptr: u)); |
2110 | } |
2111 | #else |
2112 | #define dm_compat_ctl_ioctl NULL |
2113 | #endif |
2114 | |
2115 | static int dm_open(struct inode *inode, struct file *filp) |
2116 | { |
2117 | int r; |
2118 | struct dm_file *priv; |
2119 | |
2120 | r = nonseekable_open(inode, filp); |
2121 | if (unlikely(r)) |
2122 | return r; |
2123 | |
2124 | priv = filp->private_data = kmalloc(size: sizeof(struct dm_file), GFP_KERNEL); |
2125 | if (!priv) |
2126 | return -ENOMEM; |
2127 | |
2128 | priv->global_event_nr = atomic_read(v: &dm_global_event_nr); |
2129 | |
2130 | return 0; |
2131 | } |
2132 | |
2133 | static int dm_release(struct inode *inode, struct file *filp) |
2134 | { |
2135 | kfree(objp: filp->private_data); |
2136 | return 0; |
2137 | } |
2138 | |
2139 | static __poll_t dm_poll(struct file *filp, poll_table *wait) |
2140 | { |
2141 | struct dm_file *priv = filp->private_data; |
2142 | __poll_t mask = 0; |
2143 | |
2144 | poll_wait(filp, wait_address: &dm_global_eventq, p: wait); |
2145 | |
2146 | if ((int)(atomic_read(v: &dm_global_event_nr) - priv->global_event_nr) > 0) |
2147 | mask |= EPOLLIN; |
2148 | |
2149 | return mask; |
2150 | } |
2151 | |
2152 | static const struct file_operations _ctl_fops = { |
2153 | .open = dm_open, |
2154 | .release = dm_release, |
2155 | .poll = dm_poll, |
2156 | .unlocked_ioctl = dm_ctl_ioctl, |
2157 | .compat_ioctl = dm_compat_ctl_ioctl, |
2158 | .owner = THIS_MODULE, |
2159 | .llseek = noop_llseek, |
2160 | }; |
2161 | |
2162 | static struct miscdevice _dm_misc = { |
2163 | .minor = MAPPER_CTRL_MINOR, |
2164 | .name = DM_NAME, |
2165 | .nodename = DM_DIR "/" DM_CONTROL_NODE, |
2166 | .fops = &_ctl_fops |
2167 | }; |
2168 | |
2169 | MODULE_ALIAS_MISCDEV(MAPPER_CTRL_MINOR); |
2170 | MODULE_ALIAS("devname:" DM_DIR "/" DM_CONTROL_NODE); |
2171 | |
2172 | /* |
2173 | * Create misc character device and link to DM_DIR/control. |
2174 | */ |
2175 | int __init dm_interface_init(void) |
2176 | { |
2177 | int r; |
2178 | |
2179 | r = misc_register(misc: &_dm_misc); |
2180 | if (r) { |
2181 | DMERR("misc_register failed for control device" ); |
2182 | return r; |
2183 | } |
2184 | |
2185 | DMINFO("%d.%d.%d%s initialised: %s" , DM_VERSION_MAJOR, |
2186 | DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL, DM_VERSION_EXTRA, |
2187 | DM_DRIVER_EMAIL); |
2188 | return 0; |
2189 | } |
2190 | |
2191 | void dm_interface_exit(void) |
2192 | { |
2193 | misc_deregister(misc: &_dm_misc); |
2194 | dm_hash_exit(); |
2195 | } |
2196 | |
2197 | /** |
2198 | * dm_copy_name_and_uuid - Copy mapped device name & uuid into supplied buffers |
2199 | * @md: Pointer to mapped_device |
2200 | * @name: Buffer (size DM_NAME_LEN) for name |
2201 | * @uuid: Buffer (size DM_UUID_LEN) for uuid or empty string if uuid not defined |
2202 | */ |
2203 | int dm_copy_name_and_uuid(struct mapped_device *md, char *name, char *uuid) |
2204 | { |
2205 | int r = 0; |
2206 | struct hash_cell *hc; |
2207 | |
2208 | if (!md) |
2209 | return -ENXIO; |
2210 | |
2211 | mutex_lock(&dm_hash_cells_mutex); |
2212 | hc = dm_get_mdptr(md); |
2213 | if (!hc) { |
2214 | r = -ENXIO; |
2215 | goto out; |
2216 | } |
2217 | |
2218 | if (name) |
2219 | strcpy(p: name, q: hc->name); |
2220 | if (uuid) |
2221 | strcpy(p: uuid, q: hc->uuid ? : "" ); |
2222 | |
2223 | out: |
2224 | mutex_unlock(lock: &dm_hash_cells_mutex); |
2225 | |
2226 | return r; |
2227 | } |
2228 | EXPORT_SYMBOL_GPL(dm_copy_name_and_uuid); |
2229 | |
2230 | /** |
2231 | * dm_early_create - create a mapped device in early boot. |
2232 | * |
2233 | * @dmi: Contains main information of the device mapping to be created. |
2234 | * @spec_array: array of pointers to struct dm_target_spec. Describes the |
2235 | * mapping table of the device. |
2236 | * @target_params_array: array of strings with the parameters to a specific |
2237 | * target. |
2238 | * |
2239 | * Instead of having the struct dm_target_spec and the parameters for every |
2240 | * target embedded at the end of struct dm_ioctl (as performed in a normal |
2241 | * ioctl), pass them as arguments, so the caller doesn't need to serialize them. |
2242 | * The size of the spec_array and target_params_array is given by |
2243 | * @dmi->target_count. |
2244 | * This function is supposed to be called in early boot, so locking mechanisms |
2245 | * to protect against concurrent loads are not required. |
2246 | */ |
2247 | int __init dm_early_create(struct dm_ioctl *dmi, |
2248 | struct dm_target_spec **spec_array, |
2249 | char **target_params_array) |
2250 | { |
2251 | int r, m = DM_ANY_MINOR; |
2252 | struct dm_table *t, *old_map; |
2253 | struct mapped_device *md; |
2254 | unsigned int i; |
2255 | |
2256 | if (!dmi->target_count) |
2257 | return -EINVAL; |
2258 | |
2259 | r = check_name(name: dmi->name); |
2260 | if (r) |
2261 | return r; |
2262 | |
2263 | if (dmi->flags & DM_PERSISTENT_DEV_FLAG) |
2264 | m = MINOR(huge_decode_dev(dmi->dev)); |
2265 | |
2266 | /* alloc dm device */ |
2267 | r = dm_create(minor: m, md: &md); |
2268 | if (r) |
2269 | return r; |
2270 | |
2271 | /* hash insert */ |
2272 | r = dm_hash_insert(name: dmi->name, uuid: *dmi->uuid ? dmi->uuid : NULL, md); |
2273 | if (r) |
2274 | goto err_destroy_dm; |
2275 | |
2276 | /* alloc table */ |
2277 | r = dm_table_create(result: &t, mode: get_mode(param: dmi), num_targets: dmi->target_count, md); |
2278 | if (r) |
2279 | goto err_hash_remove; |
2280 | |
2281 | /* add targets */ |
2282 | for (i = 0; i < dmi->target_count; i++) { |
2283 | r = dm_table_add_target(t, type: spec_array[i]->target_type, |
2284 | start: (sector_t) spec_array[i]->sector_start, |
2285 | len: (sector_t) spec_array[i]->length, |
2286 | params: target_params_array[i]); |
2287 | if (r) { |
2288 | DMERR("error adding target to table" ); |
2289 | goto err_destroy_table; |
2290 | } |
2291 | } |
2292 | |
2293 | /* finish table */ |
2294 | r = dm_table_complete(t); |
2295 | if (r) |
2296 | goto err_destroy_table; |
2297 | |
2298 | /* setup md->queue to reflect md's type (may block) */ |
2299 | r = dm_setup_md_queue(md, t); |
2300 | if (r) { |
2301 | DMERR("unable to set up device queue for new table." ); |
2302 | goto err_destroy_table; |
2303 | } |
2304 | |
2305 | /* Set new map */ |
2306 | dm_suspend(md, suspend_flags: 0); |
2307 | old_map = dm_swap_table(md, t); |
2308 | if (IS_ERR(ptr: old_map)) { |
2309 | r = PTR_ERR(ptr: old_map); |
2310 | goto err_destroy_table; |
2311 | } |
2312 | set_disk_ro(disk: dm_disk(md), read_only: !!(dmi->flags & DM_READONLY_FLAG)); |
2313 | |
2314 | /* resume device */ |
2315 | r = dm_resume(md); |
2316 | if (r) |
2317 | goto err_destroy_table; |
2318 | |
2319 | DMINFO("%s (%s) is ready" , md->disk->disk_name, dmi->name); |
2320 | dm_put(md); |
2321 | return 0; |
2322 | |
2323 | err_destroy_table: |
2324 | dm_table_destroy(t); |
2325 | err_hash_remove: |
2326 | down_write(sem: &_hash_lock); |
2327 | (void) __hash_remove(hc: __get_name_cell(str: dmi->name)); |
2328 | up_write(sem: &_hash_lock); |
2329 | /* release reference from __get_name_cell */ |
2330 | dm_put(md); |
2331 | err_destroy_dm: |
2332 | dm_put(md); |
2333 | dm_destroy(md); |
2334 | return r; |
2335 | } |
2336 | |