Branch data Line data Source code
1 : : /*
2 : : * Support for decoding of DM_* ioctl commands.
3 : : *
4 : : * Copyright (c) 2016 Mikulas Patocka <mpatocka@redhat.com>
5 : : * Copyright (c) 2016 Masatake Yamato <yamato@redhat.com>
6 : : * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
7 : : * Copyright (c) 2016 Eugene Syromyatnikov <evgsyr@gmail.com>
8 : : * All rights reserved.
9 : : *
10 : : * Redistribution and use in source and binary forms, with or without
11 : : * modification, are permitted provided that the following conditions
12 : : * are met:
13 : : * 1. Redistributions of source code must retain the above copyright
14 : : * notice, this list of conditions and the following disclaimer.
15 : : * 2. Redistributions in binary form must reproduce the above copyright
16 : : * notice, this list of conditions and the following disclaimer in the
17 : : * documentation and/or other materials provided with the distribution.
18 : : * 3. The name of the author may not be used to endorse or promote products
19 : : * derived from this software without specific prior written permission.
20 : : *
21 : : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 : : * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 : : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 : : * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 : : * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 : : * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 : : * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 : : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 : : * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 : : */
32 : :
33 : : #include "defs.h"
34 : :
35 : : #ifdef HAVE_LINUX_DM_IOCTL_H
36 : :
37 : : # include <linux/dm-ioctl.h>
38 : : # include <linux/ioctl.h>
39 : :
40 : : # if DM_VERSION_MAJOR == 4
41 : :
42 : : /* Definitions for command which have been added later */
43 : :
44 : : # ifndef DM_LIST_VERSIONS
45 : : # define DM_LIST_VERSIONS _IOWR(DM_IOCTL, 0xd, struct dm_ioctl)
46 : : # endif
47 : : # ifndef DM_TARGET_MSG
48 : : # define DM_TARGET_MSG _IOWR(DM_IOCTL, 0xe, struct dm_ioctl)
49 : : # endif
50 : : # ifndef DM_DEV_SET_GEOMETRY
51 : : # define DM_DEV_SET_GEOMETRY _IOWR(DM_IOCTL, 0xf, struct dm_ioctl)
52 : : # endif
53 : :
54 : :
55 : : static void
56 : 360 : dm_decode_device(const unsigned int code, const struct dm_ioctl *ioc)
57 : : {
58 [ + + ]: 360 : switch (code) {
59 : : case DM_REMOVE_ALL:
60 : : case DM_LIST_DEVICES:
61 : : case DM_LIST_VERSIONS:
62 : 30 : break;
63 : : default:
64 [ + + ]: 330 : if (ioc->dev) {
65 : 320 : tprints(", dev=");
66 : 320 : print_dev_t(ioc->dev);
67 : : }
68 [ + + ]: 330 : if (ioc->name[0]) {
69 : 320 : tprints(", name=");
70 : 320 : print_quoted_string(ioc->name, DM_NAME_LEN,
71 : : QUOTE_0_TERMINATED);
72 : : }
73 [ + + ]: 330 : if (ioc->uuid[0]) {
74 : 320 : tprints(", uuid=");
75 : 320 : print_quoted_string(ioc->uuid, DM_UUID_LEN,
76 : : QUOTE_0_TERMINATED);
77 : : }
78 : 330 : break;
79 : : }
80 : 360 : }
81 : :
82 : : static void
83 : 360 : dm_decode_values(struct tcb *tcp, const unsigned int code,
84 : : const struct dm_ioctl *ioc)
85 : : {
86 [ + - ]: 360 : if (entering(tcp)) {
87 [ + + + + ]: 360 : switch (code) {
88 : : case DM_TABLE_LOAD:
89 : 80 : tprintf(", target_count=%" PRIu32,
90 : : ioc->target_count);
91 : 80 : break;
92 : : case DM_DEV_SUSPEND:
93 [ + + ]: 20 : if (ioc->flags & DM_SUSPEND_FLAG)
94 : 10 : break;
95 : : /* Fall through */
96 : : case DM_DEV_RENAME:
97 : : case DM_DEV_REMOVE:
98 : : case DM_DEV_WAIT:
99 : 70 : tprintf(", event_nr=%" PRIu32,
100 : : ioc->event_nr);
101 : 360 : break;
102 : : }
103 [ # # ]: 0 : } else if (!syserror(tcp)) {
104 [ # # ]: 0 : switch (code) {
105 : : case DM_DEV_CREATE:
106 : : case DM_DEV_RENAME:
107 : : case DM_DEV_SUSPEND:
108 : : case DM_DEV_STATUS:
109 : : case DM_DEV_WAIT:
110 : : case DM_TABLE_LOAD:
111 : : case DM_TABLE_CLEAR:
112 : : case DM_TABLE_DEPS:
113 : : case DM_TABLE_STATUS:
114 : : case DM_TARGET_MSG:
115 : 0 : tprintf(", target_count=%" PRIu32,
116 : : ioc->target_count);
117 : 0 : tprintf(", open_count=%" PRIu32,
118 : : ioc->open_count);
119 : 0 : tprintf(", event_nr=%" PRIu32,
120 : : ioc->event_nr);
121 : 0 : break;
122 : : }
123 : : }
124 : 360 : }
125 : :
126 : : #include "xlat/dm_flags.h"
127 : :
128 : : static void
129 : 360 : dm_decode_flags(const struct dm_ioctl *ioc)
130 : : {
131 : 360 : tprints(", flags=");
132 : 360 : printflags(dm_flags, ioc->flags, "DM_???");
133 : 360 : }
134 : :
135 : : static void
136 : 80 : dm_decode_dm_target_spec(struct tcb *const tcp, const kernel_ulong_t addr,
137 : : const struct dm_ioctl *const ioc)
138 : : {
139 : : static const uint32_t target_spec_size =
140 : : sizeof(struct dm_target_spec);
141 : : uint32_t i;
142 : 80 : uint32_t offset = ioc->data_start;
143 : : uint32_t offset_end;
144 : :
145 [ + + ]: 80 : if (abbrev(tcp)) {
146 [ + + ]: 40 : if (ioc->target_count)
147 : 35 : tprints(", ...");
148 : :
149 : 40 : return;
150 : : }
151 : :
152 [ + + ]: 125 : for (i = 0; i < ioc->target_count; i++) {
153 : : struct dm_target_spec s;
154 : :
155 : 100 : offset_end = offset + target_spec_size;
156 : :
157 [ + + ][ + + ]: 100 : if (offset_end <= offset || offset_end > ioc->data_size)
158 : : goto misplaced;
159 : :
160 : 90 : tprints(", ");
161 : :
162 [ + + ]: 90 : if (i >= max_strlen) {
163 : 5 : tprints("...");
164 : 15 : break;
165 : : }
166 : :
167 [ + + ]: 85 : if (umove_or_printaddr(tcp, addr + offset, &s))
168 : 10 : break;
169 : :
170 : 75 : tprintf("{sector_start=%" PRI__u64 ", length=%" PRI__u64,
171 : : s.sector_start, s.length);
172 : :
173 [ - + ]: 75 : if (exiting(tcp))
174 : 0 : tprintf(", status=%" PRId32, s.status);
175 : :
176 : 75 : tprints(", target_type=");
177 : 75 : print_quoted_string(s.target_type, DM_MAX_TYPE_NAME,
178 : : QUOTE_0_TERMINATED);
179 : :
180 : 75 : tprints(", string=");
181 : 75 : printstr_ex(tcp, addr + offset_end, ioc->data_size - offset_end,
182 : : QUOTE_0_TERMINATED);
183 : 75 : tprints("}");
184 : :
185 [ + - ]: 75 : if (entering(tcp))
186 : 75 : offset += s.next;
187 : : else
188 : 0 : offset = ioc->data_start + s.next;
189 : :
190 [ + + ]: 75 : if (offset <= offset_end)
191 : 5 : goto misplaced;
192 : : }
193 : :
194 : 25 : return;
195 : :
196 : : misplaced:
197 : 15 : tprints(", /* misplaced struct dm_target_spec */ ...");
198 : : }
199 : :
200 : : bool
201 : 0 : dm_print_dev(struct tcb *tcp, void *dev_ptr, size_t dev_size, void *dummy)
202 : : {
203 : 0 : uint64_t *dev = (uint64_t *) dev_ptr;
204 : :
205 : 0 : print_dev_t(*dev);
206 : :
207 : 0 : return 1;
208 : : }
209 : :
210 : : static void
211 : 0 : dm_decode_dm_target_deps(struct tcb *const tcp, const kernel_ulong_t addr,
212 : : const struct dm_ioctl *const ioc)
213 : : {
214 : : static const uint32_t target_deps_dev_offs =
215 : : offsetof(struct dm_target_deps, dev);
216 : : uint64_t dev_buf;
217 : : struct dm_target_deps s;
218 : 0 : uint32_t offset = ioc->data_start;
219 : 0 : uint32_t offset_end = offset + target_deps_dev_offs;
220 : : uint32_t space;
221 : :
222 [ # # ]: 0 : if (abbrev(tcp)) {
223 : 0 : tprints(", ...");
224 : 0 : return;
225 : : }
226 : :
227 : 0 : tprints(", ");
228 : :
229 [ # # ][ # # ]: 0 : if (offset_end <= offset || offset_end > ioc->data_size)
230 : : goto misplaced;
231 : :
232 [ # # ]: 0 : if (umove_or_printaddr(tcp, addr + offset, &s))
233 : 0 : return;
234 : :
235 : 0 : space = (ioc->data_size - offset_end) / sizeof(dev_buf);
236 : :
237 [ # # ]: 0 : if (s.count > space)
238 : 0 : goto misplaced;
239 : :
240 : 0 : tprintf("{count=%u, deps=", s.count);
241 : :
242 : 0 : print_array(tcp, addr + offset_end, s.count, &dev_buf, sizeof(dev_buf),
243 : : umoven_or_printaddr, dm_print_dev, NULL);
244 : :
245 : 0 : tprints("}");
246 : :
247 : 0 : return;
248 : :
249 : : misplaced:
250 : 0 : tprints("/* misplaced struct dm_target_deps */ ...");
251 : : }
252 : :
253 : : static void
254 : 0 : dm_decode_dm_name_list(struct tcb *const tcp, const kernel_ulong_t addr,
255 : : const struct dm_ioctl *const ioc)
256 : : {
257 : : static const uint32_t name_list_name_offs =
258 : : offsetof(struct dm_name_list, name);
259 : : struct dm_name_list s;
260 : 0 : uint32_t offset = ioc->data_start;
261 : : uint32_t offset_end;
262 : : uint32_t count;
263 : :
264 [ # # ]: 0 : if (abbrev(tcp)) {
265 : 0 : tprints(", ...");
266 : 0 : return;
267 : : }
268 : :
269 : 0 : for (count = 0;; count++) {
270 : 0 : offset_end = offset + name_list_name_offs;
271 : :
272 [ # # ][ # # ]: 0 : if (offset_end <= offset || offset_end > ioc->data_size)
273 : : goto misplaced;
274 : :
275 : 0 : tprints(", ");
276 : :
277 [ # # ]: 0 : if (count >= max_strlen) {
278 : 0 : tprints("...");
279 : 0 : break;
280 : : }
281 : :
282 [ # # ]: 0 : if (umove_or_printaddr(tcp, addr + offset, &s))
283 : 0 : break;
284 [ # # ][ # # ]: 0 : if (!count && !s.dev) {
285 : 0 : tprints("/* no devices present */");
286 : 0 : break;
287 : : }
288 : :
289 : 0 : tprints("{dev=");
290 : 0 : print_dev_t(s.dev);
291 : :
292 : 0 : tprints("name=");
293 : 0 : printstr_ex(tcp, addr + offset_end, ioc->data_size - offset_end,
294 : : QUOTE_0_TERMINATED);
295 : 0 : tprints("}");
296 : :
297 [ # # ]: 0 : if (!s.next)
298 : 0 : break;
299 : :
300 : 0 : offset += s.next;
301 [ # # ]: 0 : if (offset <= offset_end)
302 : 0 : goto misplaced;
303 : : }
304 : :
305 : 0 : return;
306 : :
307 : : misplaced:
308 : 0 : tprints(", /* misplaced struct dm_name_list */ ...");
309 : : }
310 : :
311 : : static void
312 : 0 : dm_decode_dm_target_versions(struct tcb *const tcp, const kernel_ulong_t addr,
313 : : const struct dm_ioctl *const ioc)
314 : : {
315 : : static const uint32_t target_vers_name_offs =
316 : : offsetof(struct dm_target_versions, name);
317 : : struct dm_target_versions s;
318 : 0 : uint32_t offset = ioc->data_start;
319 : : uint32_t offset_end;
320 : : uint32_t count;
321 : :
322 [ # # ]: 0 : if (abbrev(tcp)) {
323 : 0 : tprints(", ...");
324 : 0 : return;
325 : : }
326 : :
327 : 0 : for (count = 0;; count++) {
328 : 0 : offset_end = offset + target_vers_name_offs;
329 : :
330 [ # # ][ # # ]: 0 : if (offset_end <= offset || offset_end > ioc->data_size)
331 : : goto misplaced;
332 : :
333 : 0 : tprints(", ");
334 : :
335 [ # # ]: 0 : if (count >= max_strlen) {
336 : 0 : tprints("...");
337 : 0 : break;
338 : : }
339 : :
340 [ # # ]: 0 : if (umove_or_printaddr(tcp, addr + offset, &s))
341 : 0 : break;
342 : :
343 : 0 : tprints("{name=");
344 : 0 : printstr_ex(tcp, addr + offset_end, ioc->data_size - offset_end,
345 : : QUOTE_0_TERMINATED);
346 : 0 : tprintf(", version=%" PRIu32 ".%" PRIu32 ".%" PRIu32 "}",
347 : : s.version[0], s.version[1], s.version[2]);
348 : :
349 [ # # ]: 0 : if (!s.next)
350 : 0 : break;
351 : :
352 : 0 : offset += s.next;
353 [ # # ]: 0 : if (offset <= offset_end)
354 : 0 : goto misplaced;
355 : : }
356 : :
357 : 0 : return;
358 : :
359 : : misplaced:
360 : 0 : tprints(", /* misplaced struct dm_target_versions */ ...");
361 : : }
362 : :
363 : : static void
364 : 60 : dm_decode_dm_target_msg(struct tcb *const tcp, const kernel_ulong_t addr,
365 : : const struct dm_ioctl *const ioc)
366 : : {
367 : : static const uint32_t target_msg_message_offs =
368 : : offsetof(struct dm_target_msg, message);
369 : 60 : uint32_t offset = ioc->data_start;
370 : 60 : uint32_t offset_end = offset + target_msg_message_offs;
371 : :
372 [ + + ]: 60 : if (abbrev(tcp)) {
373 : 30 : tprints(", ...");
374 : 30 : return;
375 : : }
376 : :
377 [ + + ][ + + ]: 45 : if (offset_end > offset && offset_end <= ioc->data_size) {
378 : : struct dm_target_msg s;
379 : :
380 : 20 : tprints(", ");
381 : :
382 [ + + ]: 20 : if (umove_or_printaddr(tcp, addr + offset, &s))
383 : 5 : return;
384 : :
385 : 15 : tprintf("{sector=%" PRI__u64 ", message=", s.sector);
386 : 15 : printstr_ex(tcp, addr + offset_end, ioc->data_size - offset_end,
387 : : QUOTE_0_TERMINATED);
388 : 15 : tprints("}");
389 : : } else {
390 : 10 : tprints(", /* misplaced struct dm_target_msg */");
391 : : }
392 : : }
393 : :
394 : : static void
395 : 50 : dm_decode_string(struct tcb *const tcp, const kernel_ulong_t addr,
396 : : const struct dm_ioctl *const ioc)
397 : : {
398 : 50 : uint32_t offset = ioc->data_start;
399 : :
400 [ + + ]: 50 : if (abbrev(tcp)) {
401 : 25 : tprints(", ...");
402 : 25 : return;
403 : : }
404 : :
405 [ + + ]: 25 : if (offset < ioc->data_size) {
406 : 20 : tprints(", string=");
407 : 20 : printstr_ex(tcp, addr + offset, ioc->data_size - offset,
408 : : QUOTE_0_TERMINATED);
409 : : } else {
410 : 5 : tprints(", /* misplaced string */");
411 : : }
412 : : }
413 : :
414 : : static inline bool
415 : 370 : dm_ioctl_has_params(const unsigned int code)
416 : : {
417 [ + + ]: 370 : switch (code) {
418 : : case DM_VERSION:
419 : : case DM_REMOVE_ALL:
420 : : case DM_DEV_CREATE:
421 : : case DM_DEV_REMOVE:
422 : : case DM_DEV_SUSPEND:
423 : : case DM_DEV_STATUS:
424 : : case DM_TABLE_CLEAR:
425 : 130 : return false;
426 : : }
427 : :
428 : 240 : return true;
429 : : }
430 : :
431 : : static int
432 : 800 : dm_known_ioctl(struct tcb *const tcp, const unsigned int code,
433 : : const kernel_ulong_t arg)
434 : : {
435 : 800 : struct dm_ioctl *ioc = NULL;
436 : 800 : struct dm_ioctl *entering_ioc = NULL;
437 : 800 : bool ioc_changed = false;
438 : :
439 [ + + ]: 800 : if (entering(tcp)) {
440 : 400 : ioc = malloc(sizeof(*ioc));
441 [ - + ]: 400 : if (!ioc)
442 : 0 : return 0;
443 : : } else {
444 : 400 : ioc = alloca(sizeof(*ioc));
445 : : }
446 : :
447 [ + + ][ + + ]: 800 : if ((umoven(tcp, arg, offsetof(struct dm_ioctl, data), ioc) < 0) ||
448 : 780 : (ioc->data_size < offsetof(struct dm_ioctl, data_size))) {
449 [ + + ]: 40 : if (entering(tcp))
450 : 20 : free(ioc);
451 : 40 : return 0;
452 : : }
453 [ + + ]: 760 : if (entering(tcp))
454 : 380 : set_tcb_priv_data(tcp, ioc, free);
455 : : else {
456 : 380 : entering_ioc = get_tcb_priv_data(tcp);
457 : :
458 : : /*
459 : : * retrieve_status, __dev_status called only in case of success,
460 : : * so it looks like there's no need to check open_count,
461 : : * event_nr, target_count, dev fields for change (they are
462 : : * printed only in case of absence of errors).
463 : : */
464 [ + - ][ + - ]: 380 : if (!entering_ioc ||
465 [ + - ]: 380 : (ioc->version[0] != entering_ioc->version[0]) ||
466 [ + - ]: 380 : (ioc->version[1] != entering_ioc->version[1]) ||
467 [ + - ]: 380 : (ioc->version[2] != entering_ioc->version[2]) ||
468 [ + - ]: 380 : (ioc->data_size != entering_ioc->data_size) ||
469 [ - + ]: 380 : (ioc->data_start != entering_ioc->data_start) ||
470 : 380 : (ioc->flags != entering_ioc->flags))
471 : 0 : ioc_changed = true;
472 : : }
473 : :
474 [ + + ][ + - ]: 760 : if (exiting(tcp) && syserror(tcp) && !ioc_changed)
[ + - ]
475 : 380 : return 1;
476 : :
477 : : /*
478 : : * device mapper code uses %d in some places and %u in another, but
479 : : * fields themselves are declared as __u32.
480 : : */
481 [ + - ]: 380 : tprintf("%s{version=%u.%u.%u", entering(tcp) ? ", " : " => ",
482 : : ioc->version[0], ioc->version[1], ioc->version[2]);
483 : : /*
484 : : * if we use a different version of ABI, do not attempt to decode
485 : : * ioctl fields
486 : : */
487 [ + + ]: 380 : if (ioc->version[0] != DM_VERSION_MAJOR) {
488 : 10 : tprints(", /* Unsupported device mapper ABI version */ ...");
489 : 10 : goto skip;
490 : : }
491 : :
492 : 370 : tprintf(", data_size=%u", ioc->data_size);
493 : :
494 [ + + ]: 370 : if (dm_ioctl_has_params(code))
495 : 240 : tprintf(", data_start=%u", ioc->data_start);
496 : :
497 [ + + ]: 370 : if (ioc->data_size < offsetof(struct dm_ioctl, data)) {
498 : 10 : tprints(", /* Incorrect data_size */ ...");
499 : 10 : goto skip;
500 : : }
501 : :
502 : 360 : dm_decode_device(code, ioc);
503 : 360 : dm_decode_values(tcp, code, ioc);
504 : 360 : dm_decode_flags(ioc);
505 : :
506 [ + + + + : 360 : switch (code) {
+ + + + ]
507 : : case DM_DEV_WAIT:
508 : : case DM_TABLE_STATUS:
509 [ - + ][ # # ]: 20 : if (entering(tcp) || syserror(tcp))
510 : : break;
511 : 0 : dm_decode_dm_target_spec(tcp, arg, ioc);
512 : 0 : break;
513 : : case DM_TABLE_LOAD:
514 [ - + ]: 80 : if (exiting(tcp))
515 : 0 : break;
516 : 80 : dm_decode_dm_target_spec(tcp, arg, ioc);
517 : 80 : break;
518 : : case DM_TABLE_DEPS:
519 [ - + ][ # # ]: 10 : if (entering(tcp) || syserror(tcp))
520 : : break;
521 : 0 : dm_decode_dm_target_deps(tcp, arg, ioc);
522 : 0 : break;
523 : : case DM_LIST_DEVICES:
524 [ - + ][ # # ]: 10 : if (entering(tcp) || syserror(tcp))
525 : : break;
526 : 0 : dm_decode_dm_name_list(tcp, arg, ioc);
527 : 0 : break;
528 : : case DM_LIST_VERSIONS:
529 [ - + ][ # # ]: 10 : if (entering(tcp) || syserror(tcp))
530 : : break;
531 : 0 : dm_decode_dm_target_versions(tcp, arg, ioc);
532 : 0 : break;
533 : : case DM_TARGET_MSG:
534 [ + - ]: 60 : if (entering(tcp))
535 : 60 : dm_decode_dm_target_msg(tcp, arg, ioc);
536 [ # # ][ # # ]: 0 : else if (!syserror(tcp) && ioc->flags & DM_DATA_OUT_FLAG)
537 : 0 : dm_decode_string(tcp, arg, ioc);
538 : 60 : break;
539 : : case DM_DEV_RENAME:
540 : : case DM_DEV_SET_GEOMETRY:
541 [ - + ]: 50 : if (exiting(tcp))
542 : 0 : break;
543 : 50 : dm_decode_string(tcp, arg, ioc);
544 : 50 : break;
545 : : }
546 : :
547 : : skip:
548 : 380 : tprints("}");
549 : 380 : return 1;
550 : : }
551 : :
552 : : int
553 : 860 : dm_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg)
554 : : {
555 [ + + ]: 860 : switch (code) {
556 : : case DM_VERSION:
557 : : case DM_REMOVE_ALL:
558 : : case DM_LIST_DEVICES:
559 : : case DM_DEV_CREATE:
560 : : case DM_DEV_REMOVE:
561 : : case DM_DEV_RENAME:
562 : : case DM_DEV_SUSPEND:
563 : : case DM_DEV_STATUS:
564 : : case DM_DEV_WAIT:
565 : : case DM_TABLE_LOAD:
566 : : case DM_TABLE_CLEAR:
567 : : case DM_TABLE_DEPS:
568 : : case DM_TABLE_STATUS:
569 : : case DM_LIST_VERSIONS:
570 : : case DM_TARGET_MSG:
571 : : case DM_DEV_SET_GEOMETRY:
572 : 800 : return dm_known_ioctl(tcp, code, arg);
573 : : default:
574 : 60 : return 0;
575 : : }
576 : : }
577 : :
578 : : # else /* !(DM_VERSION_MAJOR == 4) */
579 : :
580 : : int
581 : : dm_ioctl(struct tcb *const tcp, const unsigned int code, const kernel_ulong_t arg)
582 : : {
583 : : return 0;
584 : : }
585 : :
586 : : # endif /* DM_VERSION_MAJOR == 4 */
587 : : #endif /* HAVE_LINUX_DM_IOCTL_H */
|
