blob: 8371796dee05bdd3aba3662b595eaaabf240c866 [file] [log] [blame]
Jeff Mahoney8cc69622016-05-18 18:09:39 -04001/*
2 * Copyright (c) 2016 Jeff Mahoney <jeffm@suse.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include "defs.h"
29#include <linux/fs.h>
30#ifdef HAVE_LINUX_BTRFS_H
31/*
32 * Prior to Linux 3.12, the BTRFS_IOC_DEFAULT_SUBVOL used u64 in
33 * its definition, which isn't exported by the kernel.
34 */
35typedef __u64 u64;
36
37#include <linux/btrfs.h>
38
39#ifndef HAVE_STRUCT_BTRFS_IOCTL_FEATURE_FLAGS_COMPAT_FLAGS
40struct btrfs_ioctl_feature_flags {
41 uint64_t compat_flags;
42 uint64_t compat_ro_flags;
43 uint64_t incompat_flags;
44};
45#endif
46
47#ifndef HAVE_STRUCT_BTRFS_IOCTL_DEFRAG_RANGE_ARGS_START
48struct btrfs_ioctl_defrag_range_args {
49 uint64_t start;
50 uint64_t len;
51 uint64_t flags;
52 uint32_t extent_thresh;
53 uint32_t compress_type;
54 uint32_t unused[4];
55};
56#endif
57
58#ifndef BTRFS_SUBVOL_NAME_MAX
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +000059# define BTRFS_SUBVOL_NAME_MAX 4039
Jeff Mahoney8cc69622016-05-18 18:09:39 -040060#endif
61
62#ifndef BTRFS_LABEL_SIZE
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +000063# define BTRFS_LABEL_SIZE 256
Jeff Mahoney8cc69622016-05-18 18:09:39 -040064#endif
65
66#ifndef BTRFS_FIRST_FREE_OBJECTID
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +000067# define BTRFS_FIRST_FREE_OBJECTID 256ULL
Jeff Mahoney8cc69622016-05-18 18:09:39 -040068#endif
69
70#ifndef BTRFS_IOC_GET_FEATURES
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +000071# define BTRFS_IOC_GET_FEATURES _IOR(BTRFS_IOCTL_MAGIC, 57, \
72 struct btrfs_ioctl_feature_flags)
73# define BTRFS_IOC_SET_FEATURES _IOW(BTRFS_IOCTL_MAGIC, 57, \
74 struct btrfs_ioctl_feature_flags[2])
75# define BTRFS_IOC_GET_SUPPORTED_FEATURES _IOR(BTRFS_IOCTL_MAGIC, 57, \
76 struct btrfs_ioctl_feature_flags[3])
Jeff Mahoney8cc69622016-05-18 18:09:39 -040077#endif
78
79#ifndef BTRFS_IOC_TREE_SEARCH_V2
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +000080# define BTRFS_IOC_TREE_SEARCH_V2 _IOWR(BTRFS_IOCTL_MAGIC, 17, \
81 struct btrfs_ioctl_search_args_v2)
Jeff Mahoney8cc69622016-05-18 18:09:39 -040082struct btrfs_ioctl_search_args_v2 {
83 struct btrfs_ioctl_search_key key; /* in/out - search parameters */
84 uint64_t buf_size; /* in - size of buffer
85 * out - on EOVERFLOW: needed size
86 * to store item */
87 uint64_t buf[0]; /* out - found items */
88};
89#endif
90
91#include "xlat/btrfs_balance_args.h"
92#include "xlat/btrfs_balance_ctl_cmds.h"
93#include "xlat/btrfs_balance_flags.h"
94#include "xlat/btrfs_balance_state.h"
95#include "xlat/btrfs_compress_types.h"
96#include "xlat/btrfs_defrag_flags.h"
97#include "xlat/btrfs_dev_replace_cmds.h"
98#include "xlat/btrfs_dev_replace_results.h"
99#include "xlat/btrfs_dev_replace_state.h"
100#include "xlat/btrfs_dev_stats_flags.h"
101#include "xlat/btrfs_dev_stats_values.h"
102#include "xlat/btrfs_features_compat.h"
103#include "xlat/btrfs_features_compat_ro.h"
104#include "xlat/btrfs_features_incompat.h"
105#include "xlat/btrfs_key_types.h"
106#include "xlat/btrfs_qgroup_ctl_cmds.h"
107#include "xlat/btrfs_qgroup_inherit_flags.h"
108#include "xlat/btrfs_qgroup_limit_flags.h"
109#include "xlat/btrfs_qgroup_status_flags.h"
110#include "xlat/btrfs_scrub_flags.h"
111#include "xlat/btrfs_send_flags.h"
112#include "xlat/btrfs_snap_flags_v2.h"
113#include "xlat/btrfs_space_info_flags.h"
114#include "xlat/btrfs_tree_objectids.h"
115
116static inline char
117prnibble(char v)
118{
119 if (v >= 10)
120 return 'a' + (v - 10);
121 return '0' + v;
122}
123
124/* 8-4-4-4-12 = 36 characters */
125#define UUID_STRING_SIZE 36
126
127/* Formats uuid, returns 0 if it's all zeroes */
128static int
129btrfs_unparse_uuid(unsigned char *uuid, char *out)
130{
131 int i;
132 int ret = 0;
133 for (i = 0; i < BTRFS_UUID_SIZE; i++) {
134 if (i == 4 || i == 6 || i == 8 || i == 10)
135 *out++ = '-';
136 *out++ = prnibble(uuid[i] >> 4);
137 *out++ = prnibble(uuid[i] & 0xf);
138 if (uuid[i])
139 ret = 1;
140 }
141 *out = '\0';
142 return ret;
143}
144
145static void
146print_u64(const char *name, uint64_t value)
147{
148 tprintf(", %s=%" PRIu64, name, value);
149 if (value == UINT64_MAX)
150 tprints(" /* UINT64_MAX */");
151}
152
153#define print_member_u64(obj, name) print_u64(#name, obj->name)
154
155static void
156btrfs_print_balance_args(const char *name, struct btrfs_balance_args *bba)
157{
158 tprintf(", %s={profiles=", name);
159 printflags64(btrfs_space_info_flags, bba->profiles,
160 "BTRFS_BLOCK_GROUP_???");
161 print_member_u64(bba, usage);
162 print_member_u64(bba, devid);
163 print_member_u64(bba, pstart);
164 print_member_u64(bba, pend);
165 print_member_u64(bba, vstart);
166 print_member_u64(bba, vend);
167 print_member_u64(bba, target);
168 tprints(", flags=");
169 printflags64(btrfs_balance_args, bba->flags, "BTRFS_BALANCE_ARGS_???");
170 tprints("}");
171}
172
173static void
174btrfs_print_balance(struct tcb *tcp, const long arg, bool out)
175{
176 struct btrfs_ioctl_balance_args balance_args;
177
178 if (umove_or_printaddr(tcp, arg, &balance_args))
179 return;
180
181 tprints("{flags=");
182 printflags64(btrfs_balance_flags, balance_args.flags,
183 "BTRFS_BALANCE_???");
184 if (out) {
185 tprints(", state=");
186 printflags64(btrfs_balance_state, balance_args.state,
187 "BTRFS_BALANCE_STATE_???");
188 }
189
190 if (balance_args.flags & BTRFS_BALANCE_DATA)
191 btrfs_print_balance_args("data", &balance_args.data);
192 if (balance_args.flags & BTRFS_BALANCE_METADATA)
193 btrfs_print_balance_args("meta", &balance_args.meta);
194 if (balance_args.flags & BTRFS_BALANCE_SYSTEM)
195 btrfs_print_balance_args("sys", &balance_args.sys);
196 tprints("}");
197}
198
199static void
200btrfs_print_features(struct btrfs_ioctl_feature_flags *flags)
201{
202 tprints("{compat_flags=");
203 printflags64(btrfs_features_compat, flags->compat_flags,
204 "BTRFS_FEATURE_COMPAT_???");
205
206 tprints(", compat_ro_flags=");
207 printflags64(btrfs_features_compat_ro, flags->compat_ro_flags,
208 "BTRFS_FEATURE_COMPAT_RO_???");
209
210 tprints(", incompat_flags=");
211 printflags64(btrfs_features_incompat, flags->incompat_flags,
212 "BTRFS_FEATURE_INCOMPAT_???");
213 tprints("}");
214}
215
216static void
217btrfs_print_qgroup_limit(struct btrfs_qgroup_limit *lim)
218{
219 tprints("{flags=");
220 printflags64(btrfs_qgroup_limit_flags, lim->flags,
221 "BTRFS_QGROUP_LIMIT_???");
222 tprintf(", max_rfer=%" PRI__u64 ", max_excl=%" PRI__u64
223 ", rsv_rfer=%" PRI__u64 ", rsv_excl=%" PRI__u64 "}",
224 lim->max_rfer, lim->max_excl,
225 lim->rsv_rfer, lim->rsv_excl);
226}
227
228static void
229btrfs_print_key_type(uint32_t type)
230{
231 const char *str = xlookup(btrfs_key_types, type);
232 tprintf("%u", type);
233 if (str)
234 tprintf(" /* %s */", str);
235}
236
237static void
238btrfs_print_objectid(uint64_t objectid)
239{
240 const char *str = xlookup(btrfs_tree_objectids, objectid);
241 tprintf("%" PRIu64, objectid);
242 if (str)
243 tprintf(" /* %s */", str);
244}
245
246static void
247btrfs_print_data_container_header(struct btrfs_data_container *container)
248{
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +0000249 tprintf("{bytes_left=%u, bytes_missing=%u"
250 ", elem_cnt=%u, elem_missed=%u, val=",
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400251 container->bytes_left, container->bytes_missing,
252 container->elem_cnt, container->elem_missed);
253}
254
255static void
256btrfs_print_data_container_footer(void)
257{
258 tprints("}");
259}
260
261static uint64_t
262data_container_record_offset(unsigned int index)
263{
264 return offsetof(struct btrfs_data_container, val[index]);
265}
266
267static void
268btrfs_print_logical_ino_container(struct tcb *tcp, uint64_t inodes_addr)
269{
270 struct btrfs_data_container container;
271 uint32_t i;
272 uint32_t printed = 0;
273
274 if (umoven_or_printaddr(tcp, inodes_addr,
275 sizeof(container), &container))
276 return;
277
278 btrfs_print_data_container_header(&container);
279 if (abbrev(tcp)) {
280 tprints("...");
281 btrfs_print_data_container_footer();
282 return;
283 }
284
285 tprints("[");
286
287 for (i = 0; i < container.elem_cnt; i += 3, printed++) {
288 uint64_t offset = data_container_record_offset(i);
289 uint64_t record[3];
290
291 if (i)
292 tprints(", ");
293
294 if (printed > max_strlen ||
295 umoven(tcp, inodes_addr + offset, sizeof(record), record)) {
296 tprints("...");
297 break;
298 }
299 tprintf("{inum=%" PRIu64 ", offset=%" PRIu64
300 ", root=%" PRIu64 "}", record[0], record[1], record[2]);
301 }
302 tprints("]");
303 btrfs_print_data_container_footer();
304}
305
306static void
307btrfs_print_ino_path_container(struct tcb *tcp, uint64_t fspath_addr)
308{
309 struct btrfs_data_container container;
310 uint32_t i;
311
312 if (umoven_or_printaddr(tcp, fspath_addr,
313 sizeof(container), &container))
314 return;
315
316 btrfs_print_data_container_header(&container);
317 if (abbrev(tcp)) {
318 tprints("...");
319 btrfs_print_data_container_footer();
320 return;
321 }
322
323 tprints("[");
324
325 for (i = 0; i < container.elem_cnt; i++) {
326 uint64_t offset = data_container_record_offset(i);
327 uint64_t ptr;
328
329 if (i)
330 tprints(", ");
331
332 if (i > max_strlen ||
333 umoven(tcp, fspath_addr + offset, sizeof(ptr), &ptr)) {
334 tprints("...");
335 break;
336 }
337
338 printpath(tcp,
339 fspath_addr + data_container_record_offset(0) + ptr);
340 }
341 tprints("]");
342 btrfs_print_data_container_footer();
343}
344
345static void
346btrfs_print_qgroup_inherit(struct tcb *tcp, uint64_t qgi_addr)
347{
348 struct btrfs_qgroup_inherit inherit;
349
350 if (umoven_or_printaddr(tcp, qgi_addr, sizeof(inherit), &inherit) < 0)
351 return;
352
353 tprintf("{flags=");
354 printflags64(btrfs_qgroup_inherit_flags, inherit.flags,
355 "BTRFS_QGROUP_INHERIT_???");
356 tprintf(", num_qgroups=%" PRI__u64 ", num_ref_copies=%" PRI__u64
357 ", num_excl_copies=%" PRI__u64 ", lim=",
358 inherit.num_qgroups, inherit.num_ref_copies,
359 inherit.num_excl_copies);
360
361 btrfs_print_qgroup_limit(&inherit.lim);
362
363 tprints(", qgroups=");
364
365 if (abbrev(tcp)) {
366 tprints("...");
367 } else {
368 uint32_t i;
369
370 tprints("[");
371 for (i = 0; i < inherit.num_qgroups; i++) {
372 uint64_t offset = offsetof(typeof(inherit), qgroups[i]);
373 uint64_t record;
374 if (i)
375 tprints(", ");
376 if (i > max_strlen ||
377 umoven(tcp, qgi_addr + offset,
378 sizeof(record), &record)) {
379 tprints("...");
380 break;
381 }
382
383 tprintf("%" PRIu64, record);
384 }
385 tprints("]");
386 }
387 tprints("}");
388}
389
390static void
391print_key_value_internal(struct tcb *tcp, const char *name, uint64_t value)
392{
393 if (value) {
394 tprintf(", %s=%" PRIu64, name, value);
395 if (value == UINT64_MAX)
396 tprints(" /* UINT64_MAX */");
397 }
398}
399#define print_key_value(tcp, key, name) \
400 print_key_value_internal((tcp), #name, (key)->name)
401
402static void
403btrfs_print_tree_search(struct tcb *tcp, struct btrfs_ioctl_search_key *key,
404 uint64_t buf_addr, uint64_t buf_size, bool print_size)
405{
406 if (entering(tcp)) {
407 tprintf("{key={tree_id=");
408 btrfs_print_objectid(key->tree_id);
409
410 if (key->min_objectid != BTRFS_FIRST_FREE_OBJECTID ||
411 !abbrev(tcp)) {
412 tprints(", min_objectid=");
413 btrfs_print_objectid(key->min_objectid);
414 }
415
416 if (key->max_objectid != BTRFS_LAST_FREE_OBJECTID ||
417 !abbrev(tcp)) {
418 tprints(", max_objectid=");
419 btrfs_print_objectid(key->max_objectid);
420 }
421
422 print_key_value(tcp, key, min_offset);
423 print_key_value(tcp, key, max_offset);
424 print_key_value(tcp, key, min_transid);
425 print_key_value(tcp, key, max_transid);
426
427 tprints(", min_type=");
428 btrfs_print_key_type(key->min_type);
429 tprints(", max_type=");
430 btrfs_print_key_type(key->max_type);
431 tprintf(", nr_items=%u}", key->nr_items);
432 if (print_size)
433 tprintf(", buf_size=%" PRIu64, buf_size);
434 tprints("}");
435 return;
436 }
437 tprintf("{key={nr_items=%u}", key->nr_items);
438 if (print_size)
439 tprintf(", buf_size=%" PRIu64, buf_size);
440 tprints(", buf=");
441 if (abbrev(tcp))
442 tprints("...");
443 else {
444 uint64_t i;
445 uint64_t off = 0;
446 tprints("[");
447 for (i = 0; i < key->nr_items; i++) {
448 struct btrfs_ioctl_search_header sh;
449 uint64_t addr = buf_addr + off;
450 if (i)
451 tprints(", ");
452 if (i > max_strlen ||
453 umoven(tcp, addr, sizeof(sh), &sh)) {
454 tprints("...");
455 break;
456 }
457 tprintf("{transid=%" PRI__u64 ", objectid=",
458 sh.transid);
459 btrfs_print_objectid(sh.objectid);
460 tprintf(", offset=%" PRI__u64 ", type=", sh.offset);
461 btrfs_print_key_type(sh.type);
462 tprintf(", len=%u}", sh.len);
463 off += sizeof(sh) + sh.len;
464 }
465 tprints("]");
466 }
467
468 tprints("}");
469}
470
471int
472btrfs_ioctl(struct tcb *tcp, const unsigned int code, const long arg)
473{
474 int ret = 0;
475
476 switch (code) {
477 /* Take no arguments; Command only. */
478 case BTRFS_IOC_TRANS_START:
479 case BTRFS_IOC_TRANS_END:
480 case BTRFS_IOC_SYNC:
481 case BTRFS_IOC_SCRUB_CANCEL:
482 case BTRFS_IOC_QUOTA_RESCAN_WAIT:
483 /*
484 * The codes for these ioctls are based on each accepting a
485 * vol_args but none of them actually consume an argument.
486 */
487 case BTRFS_IOC_DEFRAG:
488 case BTRFS_IOC_BALANCE:
489 break;
490
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000491 /* takes a signed int */
492 case BTRFS_IOC_BALANCE_CTL:
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400493 tprints(", ");
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000494 printxval(btrfs_balance_ctl_cmds, arg, "BTRFS_BALANCE_CTL_???");
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400495 break;
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400496
497 /* returns a 64 */
498 case BTRFS_IOC_START_SYNC: /* R */
499 if (entering(tcp))
500 return 0;
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000501 /* fall through */
502 /* takes a u64 */
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400503 case BTRFS_IOC_DEFAULT_SUBVOL: /* W */
504 case BTRFS_IOC_WAIT_SYNC: /* W */
505 tprints(", ");
506 printnum_int64(tcp, arg, "%" PRIu64);
507 break;
508
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000509 /* u64 but describe a flags bitfield; we can make that symbolic */
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400510 case BTRFS_IOC_SUBVOL_GETFLAGS: { /* R */
511 uint64_t flags;
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000512
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400513 if (entering(tcp))
514 return 0;
515
516 tprints(", ");
517
518 if (umove_or_printaddr(tcp, arg, &flags))
519 break;
520
521 printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???");
522 break;
523 }
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000524
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400525 case BTRFS_IOC_SUBVOL_SETFLAGS: { /* W */
526 uint64_t flags;
527
528 tprints(", ");
529
530 if (umove_or_printaddr(tcp, arg, &flags))
531 break;
532
533 printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???");
534 break;
535 }
536
537 /* More complex types */
538 case BTRFS_IOC_BALANCE_V2: /* RW */
539 if (entering(tcp)) {
540 tprints(", ");
541 btrfs_print_balance(tcp, arg, false);
542 return 0;
543 }
544
545 if (syserror(tcp))
546 break;
547
548 tprints(" => ");
549 btrfs_print_balance(tcp, arg, true);
550 break;
551 case BTRFS_IOC_BALANCE_PROGRESS: /* R */
552 if (entering(tcp))
553 return 0;
554
555 tprints(", ");
556 btrfs_print_balance(tcp, arg, true);
557 break;
558
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000559 case BTRFS_IOC_DEFRAG_RANGE: { /* W */
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400560 struct btrfs_ioctl_defrag_range_args args;
561
562 tprints(", ");
563
564 if (umove_or_printaddr(tcp, arg, &args))
565 break;
566
567 tprintf("{start=%" PRIu64 ", len=", (uint64_t)args.start);
568
569 tprintf("%" PRIu64, args.len);
570 if (args.len == UINT64_MAX)
571 tprints(" /* UINT64_MAX */");
572
573 tprints(", flags=");
574 printflags64(btrfs_defrag_flags, args.flags,
575 "BTRFS_DEFRAG_RANGE_???");
576 tprintf(", extent_thresh=%u, compress_type=",
577 args.extent_thresh);
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000578 printxval(btrfs_compress_types, args.compress_type,
579 "BTRFS_COMPRESS_???");
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400580 tprints("}");
581 break;
582 }
583
584 case BTRFS_IOC_DEV_INFO: { /* RW */
585 struct btrfs_ioctl_dev_info_args args;
586 char uuid[UUID_STRING_SIZE+1];
587 int valid;
588
589 if (entering(tcp))
590 tprints(", ");
591 else if (syserror(tcp))
592 break;
593 else
594 tprints(" => ");
595 if (umove_or_printaddr(tcp, arg, &args))
596 break;
597 tprints("{");
598
599 valid = btrfs_unparse_uuid(args.uuid, uuid);
600 if (entering(tcp)) {
601 tprintf("devid=%" PRI__u64, args.devid);
602 if (valid)
603 tprintf(", uuid=%s", uuid);
604 tprints("}");
605 return 0;
606 }
607 if (valid)
608 tprintf("uuid=%s, ", uuid);
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +0000609 tprintf("bytes_used=%" PRI__u64
610 ", total_bytes=%" PRI__u64 ", path=",
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400611 args.bytes_used, args.total_bytes);
612 print_quoted_string((const char *)args.path, sizeof(args.path),
613 QUOTE_0_TERMINATED);
614 tprints("}");
615 break;
616 }
617
618 case BTRFS_IOC_DEV_REPLACE: { /* RW */
619 struct btrfs_ioctl_dev_replace_args args;
620
621 if (entering(tcp))
622 tprints(", ");
623 else if (syserror(tcp))
624 break;
625 else
626 tprints(" => ");
627
628 if (umove_or_printaddr(tcp, arg, &args))
629 break;
630
631 if (entering(tcp)) {
632 tprints("{cmd=");
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000633 printxval64(btrfs_dev_replace_cmds, args.cmd,
634 "BTRFS_IOCTL_DEV_REPLACE_CMD_???");
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400635 if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_START) {
636 const char *str;
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +0000637 tprintf(", start={srcdevid=%" PRI__u64
638 ", cont_reading_from_srcdev_mode=%" PRI__u64
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400639 ", srcdev_name=",
640 args.start.srcdevid,
641 args.start.cont_reading_from_srcdev_mode);
642
643 str = (const char*) args.start.srcdev_name;
644 print_quoted_string(str,
645 sizeof(args.start.srcdev_name),
646 QUOTE_0_TERMINATED);
647 tprints(", tgtdev_name=");
648 str = (const char*) args.start.tgtdev_name;
649 print_quoted_string(str,
650 sizeof(args.start.tgtdev_name),
651 QUOTE_0_TERMINATED);
652 tprints("}");
653
654 }
655 tprints("}");
656 return 0;
657 }
658
659 tprints("{result=");
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000660 printxval64(btrfs_dev_replace_results, args.result,
661 "BTRFS_IOCTL_DEV_REPLACE_RESULT_???");
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400662 if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS) {
663 char buf[sizeof("HH:MM:SS") + 1];
664 time_t time;
665 tprints(", ");
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000666 printxval64(btrfs_dev_replace_state,
667 args.status.replace_state,
668 "BTRFS_IOCTL_DEV_REPLACE_STATE_???");
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400669 tprintf(", progress_1000=%" PRI__u64 " /* ",
670 args.status.progress_1000);
671 if (args.status.progress_1000 <= 1000)
672 tprintf("%" PRI__u64 ".%.2" PRI__u64 "%%",
673 args.status.progress_1000 / 10,
674 args.status.progress_1000 % 10);
675 else
676 tprints("???");
677 tprints(" */ ,");
678
679 time = args.status.time_started;
680 strftime(buf, sizeof(buf), "%T",
681 localtime(&time));
682 tprintf("time_started=%" PRI__u64" /* %s */, ",
683 args.status.time_started, buf);
684
685 time = args.status.time_stopped;
686 strftime(buf, sizeof(buf), "%T",
687 localtime(&time));
688 tprintf("time_stopped=%" PRI__u64" /* %s */, ",
689 args.status.time_stopped, buf);
690
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +0000691 tprintf("num_write_errors=%" PRI__u64
692 ", num_uncorrectable_read_errors=%" PRI__u64,
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400693 args.status.num_write_errors,
694 args.status.num_uncorrectable_read_errors);
695 }
696 tprints("}");
697 break;
698 }
699
700 case BTRFS_IOC_GET_FEATURES: { /* R */
701 struct btrfs_ioctl_feature_flags flags;
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000702
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400703 if (entering(tcp))
704 return 0;
705
706 tprints(", ");
707 if (umove_or_printaddr(tcp, arg, &flags))
708 break;
709
710 btrfs_print_features(&flags);
711 break;
712 }
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000713
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400714 case BTRFS_IOC_SET_FEATURES: { /* W */
715 struct btrfs_ioctl_feature_flags flarg[2];
716
717 tprints(", ");
718
719 if (umove_or_printaddr(tcp, arg, &flarg))
720 break;
721
722 tprints("[");
723 btrfs_print_features(&flarg[0]);
724 tprints(", ");
725 btrfs_print_features(&flarg[1]);
726 tprints("]");
727 break;
728 }
729
730 case BTRFS_IOC_GET_SUPPORTED_FEATURES: { /* R */
731 struct btrfs_ioctl_feature_flags flarg[3];
732
733 if (entering(tcp))
734 return 0;
735
736 tprints(", ");
737 if (umove_or_printaddr(tcp, arg, &flarg))
738 break;
739
740 tprints("[ /* supported */ ");
741 btrfs_print_features(&flarg[0]);
742
743 tprints(", /* safe to set */ ");
744 btrfs_print_features(&flarg[1]);
745
746 tprints(", /* safe to clear */ ");
747 btrfs_print_features(&flarg[2]);
748 tprints("]");
749
750 break;
751 }
752
753 case BTRFS_IOC_FS_INFO: { /* R */
754 struct btrfs_ioctl_fs_info_args args;
755 char uuid[UUID_STRING_SIZE+1];
756 uint32_t nodesize, sectorsize, clone_alignment;
757#ifndef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE
758 __u32 *reserved32;
759#endif
760
761 if (entering(tcp))
762 return 0;
763
764 tprints(", ");
765 if (umove_or_printaddr(tcp, arg, &args))
766 break;
767
768#ifdef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE
769 nodesize = args.nodesize,
770 sectorsize = args.sectorsize,
771 clone_alignment = args.clone_alignment;
772#else
773 reserved32 = (__u32 *)args.reserved;
774 nodesize = reserved32[0];
775 sectorsize = reserved32[1];
776 clone_alignment = reserved32[2];
777#endif
778 btrfs_unparse_uuid(args.fsid, uuid);
779
780 tprints("{");
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +0000781 tprintf("max_id=%" PRI__u64 ", num_devices=%" PRI__u64
782 ", fsid=%s, nodesize=%u, sectorsize=%u"
783 ", clone_alignment=%u",
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400784 args.max_id, args.num_devices, uuid,
785 nodesize, sectorsize, clone_alignment);
786 tprints("}");
787 break;
788 }
789
790 case BTRFS_IOC_GET_DEV_STATS: { /* RW */
791 struct btrfs_ioctl_get_dev_stats args;
792 uint64_t i, max_nr_items;
793
794 if (entering(tcp))
795 tprints(", ");
796 else if (syserror(tcp))
797 break;
798 else
799 tprints(" => ");
800 if (umove_or_printaddr(tcp, arg, &args))
801 break;
802
803 tprints("{");
804
805 if (entering(tcp))
806 tprintf("devid=%" PRI__u64 ", ", args.devid);
807
808 tprintf("nr_items=%" PRI__u64 ", flags=", args.nr_items);
809 printflags64(btrfs_dev_stats_flags, args.flags,
810 "BTRFS_DEV_STATS_???");
811
812 if (entering(tcp)) {
813 tprints("}");
814 return 0;
815 }
816
817 /*
818 * The structure has a 1k limit; Let's make sure we don't
819 * go off into the middle of nowhere with a bad nr_items
820 * value.
821 */
822 max_nr_items = sizeof(args) - offsetof(typeof(args), values);
823
824 tprints(", [");
825 for (i = 0; i < args.nr_items; i++) {
826 const char *name = xlookup(btrfs_dev_stats_values, i);
827 if (i)
828 tprints(", ");
829 if (i > max_nr_items) {
830 tprints("/* overflow */");
831 break;
832 }
833 if (name)
834 tprintf("/* %s */ ", name);
835 tprintf("%" PRI__u64, args.values[i]);
836 }
837 tprints("]}");
838 break;
839 }
840
841 case BTRFS_IOC_INO_LOOKUP: { /* RW */
842 struct btrfs_ioctl_ino_lookup_args args;
843
844 if (entering(tcp))
845 tprints(", ");
846 else if (syserror(tcp))
847 break;
848 else
849 tprints(" => ");
850
851 if (umove_or_printaddr(tcp, arg, &args))
852 break;
853
854 if (entering(tcp)) {
855 /* Use subvolume id of the containing root */
856 if (args.treeid == 0)
857 /* abuse of auxstr to retain state */
858 tcp->auxstr = (void *)1;
859 else
860 tcp->auxstr = NULL;
861
862 tprints("{treeid=");
863 btrfs_print_objectid(args.treeid);
864 tprints(", objectid=");
865 btrfs_print_objectid(args.objectid);
866 tprints("}");
867 return 0;
868 }
869
870 tprints("{");
871 if (tcp->auxstr) {
872 tprints("treeid=");
873 btrfs_print_objectid(args.treeid);
874 tprints(", ");
875 }
876 tcp->auxstr = NULL;
877
878 tprints("name=");
879 print_quoted_string(args.name, sizeof(args.name),
880 QUOTE_0_TERMINATED);
881 tprints("}");
882 break;
883 }
884
885 case BTRFS_IOC_INO_PATHS: { /* RW */
886 struct btrfs_ioctl_ino_path_args args;
887
888 if (entering(tcp))
889 tprints(", ");
890 else if (syserror(tcp))
891 break;
892 else
893 tprints(" => ");
894
895 if (umove_or_printaddr(tcp, arg, &args))
896 break;
897
898 tprints("{");
899
900 if (entering(tcp)) {
901 tprintf("inum=%" PRI__u64 ", size=%" PRI__u64,
902 args.inum, args.size);
903 tprintf(", fspath=0x%" PRI__x64 "}", args.fspath);
904 return 0;
905 }
906
907 tprints("fspath=");
908 btrfs_print_ino_path_container(tcp, args.fspath);
909
910 tprints("}");
911 break;
912 }
913
914 case BTRFS_IOC_LOGICAL_INO: { /* RW */
915 struct btrfs_ioctl_logical_ino_args args;
916
917 if (entering(tcp))
918 tprints(", ");
919 else if (syserror(tcp))
920 break;
921 else
922 tprints(" => ");
923
924 if (umove_or_printaddr(tcp, arg, &args))
925 break;
926
927 tprints("{");
928
929 if (entering(tcp)) {
930 tprintf("logical=%" PRI__u64 ", size=%" PRI__u64,
931 args.logical, args.size);
932 tprintf(", inodes=0x%" PRI__x64 "}", args.inodes);
933 return 0;
934 }
935
936 tprints("inodes=");
937 btrfs_print_logical_ino_container(tcp, args.inodes);
938
939 tprints("}");
940 break;
941 }
942
943 case BTRFS_IOC_QGROUP_ASSIGN: { /* W */
944 struct btrfs_ioctl_qgroup_assign_args args;
945
946 tprints(", ");
947 if (umove_or_printaddr(tcp, arg, &args))
948 break;
949
950 tprintf("{assign=%" PRI__u64 ", src=%" PRI__u64
951 ", dst=%" PRI__u64 "}",
952 args.assign, args.src, args.dst);
953 break;
954 }
955
956 case BTRFS_IOC_QGROUP_CREATE: { /* W */
957 struct btrfs_ioctl_qgroup_create_args args;
958
959 tprints(", ");
960 if (umove_or_printaddr(tcp, arg, &args))
961 break;
962
963 tprintf("{create=%" PRI__u64 ", qgroupid=%" PRI__u64 "}",
964 args.create, args.qgroupid);
965 break;
966 }
967
968 case BTRFS_IOC_QGROUP_LIMIT: { /* R */
969 struct btrfs_ioctl_qgroup_limit_args args;
970
971 if (entering(tcp))
972 return 0;
973
974 tprints(", ");
975 if (umove_or_printaddr(tcp, arg, &args))
976 break;
977
978 tprintf("{qgroupid=%" PRI__u64 ", lim=", args.qgroupid);
979 btrfs_print_qgroup_limit(&args.lim);
980 tprints("}");
981 break;
982 }
983
984 case BTRFS_IOC_QUOTA_CTL: { /* W */
985 struct btrfs_ioctl_quota_ctl_args args;
986
987 tprints(", ");
988 if (umove_or_printaddr(tcp, arg, &args))
989 break;
990
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000991 printxval64(btrfs_qgroup_ctl_cmds, args.cmd,
992 "BTRFS_QUOTA_CTL_???");
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400993 tprints("}");
994
995 break;
996 }
Dmitry V. Levin95577cf2016-05-24 00:35:49 +0000997
Jeff Mahoney8cc69622016-05-18 18:09:39 -0400998 case BTRFS_IOC_QUOTA_RESCAN: { /* W */
999 struct btrfs_ioctl_quota_rescan_args args;
1000
1001 tprints(", ");
1002 if (umove_or_printaddr(tcp, arg, &args))
1003 break;
1004
1005 tprintf("{flags=%" PRI__u64 "}", args.flags);
1006 break;
1007 }
Dmitry V. Levin95577cf2016-05-24 00:35:49 +00001008
Jeff Mahoney8cc69622016-05-18 18:09:39 -04001009 case BTRFS_IOC_QUOTA_RESCAN_STATUS: { /* R */
1010 struct btrfs_ioctl_quota_rescan_args args;
1011
1012 if (entering(tcp))
1013 return 0;
1014
1015 tprints(", ");
1016 if (umove_or_printaddr(tcp, arg, &args))
1017 break;
1018
1019 tprintf("{flags=%" PRI__u64 ", progress=", args.flags);
1020 btrfs_print_objectid(args.progress);
1021 tprints("}");
1022 break;
1023 }
Dmitry V. Levin95577cf2016-05-24 00:35:49 +00001024
Jeff Mahoney8cc69622016-05-18 18:09:39 -04001025 case BTRFS_IOC_SET_RECEIVED_SUBVOL: { /* RW */
1026#ifdef BTRFS_IOC_SET_RECEIVED_SUBVOL_32
1027 case BTRFS_IOC_SET_RECEIVED_SUBVOL_32: { /* RW */
1028 struct btrfs_ioctl_received_subvol_args_32 args32;
1029#endif
1030 struct btrfs_ioctl_received_subvol_args args;
1031 char uuid[UUID_STRING_SIZE+1];
1032
1033 if (entering(tcp))
1034 tprints(", ");
1035 else if (syserror(tcp))
1036 break;
1037 else
1038 tprints(" => ");
1039
1040#ifdef BTRFS_IOC_SET_RECEIVED_SUBVOL_32
1041 /*
1042 * This is a compat ioctl for 32 bit tools on
1043 * 64 bit systems.
1044 */
1045 if (code == BTRFS_IOC_SET_RECEIVED_SUBVOL_32) {
1046 if (umove_or_printaddr(tcp, arg, &args32))
1047 break;
1048 memcpy(args.uuid, args32.uuid, sizeof(uuid));
1049 args.stransid = args32.stransid;
1050 args.rtransid = args32.rtransid;
1051 args.stime.sec = args32.stime.sec;
1052 args.stime.nsec = args32.stime.nsec;
1053 args.rtime.sec = args32.rtime.sec;
1054 args.rtime.nsec = args32.rtime.nsec;
1055 args.flags = args32.flags;
1056 } else
1057#endif
1058 if (umove_or_printaddr(tcp, arg, &args))
1059 break;
1060
1061 if (entering(tcp)) {
1062 btrfs_unparse_uuid((unsigned char *)args.uuid, uuid);
1063 tprintf("{uuid=%s, stransid=%" PRI__u64
1064 ", stime=%" PRI__u64 ".%u, flags=%" PRI__u64
1065 "}", uuid, args.stransid, args.stime.sec,
1066 args.stime.nsec, args.flags);
1067 return 0;
1068 }
1069 tprintf("{rtransid=%" PRI__u64 ", rtime=%" PRI__u64 ".%u}",
1070 args.rtransid, args.rtime.sec, args.rtime.nsec);
1071 break;
1072 }
Dmitry V. Levin95577cf2016-05-24 00:35:49 +00001073
Jeff Mahoney8cc69622016-05-18 18:09:39 -04001074 case BTRFS_IOC_SCRUB: /* RW */
1075 case BTRFS_IOC_SCRUB_PROGRESS: { /* RW */
1076 struct btrfs_ioctl_scrub_args args;
1077
1078 if (entering(tcp))
1079 tprints(", ");
1080 else if (syserror(tcp))
1081 break;
1082 else
1083 tprints(" => ");
1084
1085 if (umove_or_printaddr(tcp, arg, &args))
1086 break;
1087
1088 if (entering(tcp)) {
1089 tprintf("{devid=%" PRI__u64, args.devid);
1090 if (code == BTRFS_IOC_SCRUB) {
1091 tprintf(", start=%" PRI__u64 ", end=",
1092 args.start);
1093 tprintf("%" PRI__u64, args.end);
1094 if (args.end == UINT64_MAX)
1095 tprints(" /* UINT64_MAX */");
1096 tprints(", flags=");
1097 printflags64(btrfs_scrub_flags, args.flags,
1098 "BTRFS_SCRUB_???");
1099 }
1100 tprints("}");
1101 return 0;
1102 }
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +00001103 tprintf("{data_extents_scrubbed=%" PRI__u64
1104 ", tree_extents_scrubbed=%" PRI__u64
1105 ", data_bytes_scrubbed=%" PRI__u64
1106 ", tree_bytes_scrubbed=%" PRI__u64
1107 ", read_errors=%" PRI__u64
1108 ", csum_errors=%" PRI__u64
1109 ", verify_errors=%" PRI__u64
1110 ", no_csum=%" PRI__u64
1111 ", csum_discards=%" PRI__u64
1112 ", super_errors=%" PRI__u64
1113 ", malloc_errors=%" PRI__u64
1114 ", uncorrectable_errors=%" PRI__u64
1115 ", corrected_errors=%" PRI__u64
1116 ", last_physical=%" PRI__u64
1117 ", unverified_errors=%" PRI__u64 "}",
Jeff Mahoney8cc69622016-05-18 18:09:39 -04001118 args.progress.data_extents_scrubbed,
1119 args.progress.tree_extents_scrubbed,
1120 args.progress.data_bytes_scrubbed,
1121 args.progress.tree_bytes_scrubbed,
1122 args.progress.read_errors,
1123 args.progress.csum_errors,
1124 args.progress.verify_errors,
1125 args.progress.no_csum,
1126 args.progress.csum_discards,
1127 args.progress.super_errors,
1128 args.progress.malloc_errors,
1129 args.progress.uncorrectable_errors,
1130 args.progress.corrected_errors,
1131 args.progress.last_physical,
1132 args.progress.unverified_errors);
1133 break;
1134 }
1135
1136 case BTRFS_IOC_TREE_SEARCH: { /* RW */
1137 struct btrfs_ioctl_search_args args;
1138 uint64_t buf_offset;
1139
1140 if (entering(tcp))
1141 tprints(", ");
1142 else if (syserror(tcp))
1143 break;
1144 else
1145 tprints(" => ");
1146
1147 if (umove_or_printaddr(tcp, arg, &args))
1148 break;
1149
1150 buf_offset = offsetof(struct btrfs_ioctl_search_args, buf);
1151 btrfs_print_tree_search(tcp, &args.key, arg + buf_offset,
1152 sizeof(args.buf), false);
1153 if (entering(tcp))
1154 return 0;
1155 break;
1156 }
1157
1158 case BTRFS_IOC_TREE_SEARCH_V2: { /* RW */
1159 struct btrfs_ioctl_search_args_v2 args;
1160 uint64_t buf_offset;
1161
1162 if (entering(tcp))
1163 tprints(", ");
1164 else if (syserror(tcp)) {
1165 if (tcp->u_error == EOVERFLOW) {
1166 tcp->u_error = 0;
1167 if (!umove_or_printaddr(tcp, arg, &args))
1168 tprintf(" => {buf_size=%" PRIu64 "}",
1169 (uint64_t)args.buf_size);
1170 tcp->u_error = EOVERFLOW;
1171 }
1172 break;
1173 } else
1174 tprints(" => ");
1175
1176 if (umove_or_printaddr(tcp, arg, &args))
1177 break;
1178
1179 buf_offset = offsetof(struct btrfs_ioctl_search_args_v2, buf);
1180 btrfs_print_tree_search(tcp, &args.key, arg + buf_offset,
1181 args.buf_size, true);
1182 if (entering(tcp))
1183 return 0;
1184 break;
1185 }
1186
1187 case BTRFS_IOC_SEND: { /* W */
1188 struct btrfs_ioctl_send_args args;
1189 uint64_t base_addr;
1190 uint64_t i;
1191
1192 tprints(", ");
1193 if (umove_or_printaddr(tcp, arg, &args))
1194 break;
1195
1196 tprintf("{send_fd=%" PRI__d64 ", clone_sources_count=%" PRI__u64
1197 ", clone_sources=", args.send_fd,
1198 args.clone_sources_count);
1199
1200 if (abbrev(tcp)) {
1201 tprints("...");
1202 } else {
1203 tprints("[");
1204 base_addr = (unsigned long)args.clone_sources;
1205 for (i = 0; i < args.clone_sources_count; i++) {
1206 uint64_t offset = sizeof(uint64_t) * i;
1207 uint64_t record;
1208 if (i)
1209 tprints(", ");
1210 if (i > max_strlen ||
1211 umoven(tcp, base_addr + offset,
1212 sizeof(record), &record)) {
1213 tprints("...");
1214 break;
1215 }
1216 btrfs_print_objectid(record);
1217 }
1218 tprints("]");
1219 }
1220 tprints(", parent_root=");
1221 btrfs_print_objectid(args.parent_root);
1222 tprints(", flags=");
1223 printflags64(btrfs_send_flags, args.flags,
1224 "BTRFS_SEND_FLAGS_???");
1225 tprints("}");
1226 break;
1227 }
1228
1229 case BTRFS_IOC_SPACE_INFO: { /* RW */
1230 struct btrfs_ioctl_space_args args;
1231 uint64_t i;
1232
1233 if (entering(tcp))
1234 tprints(", ");
1235 else if (syserror(tcp))
1236 break;
1237 else
1238 tprints(" => ");
1239
1240 if (umove_or_printaddr(tcp, arg, &args))
1241 break;
1242
1243 tprints("{");
1244 if (entering(tcp)) {
Dmitry V. Levin2be39ec2016-05-24 00:23:31 +00001245 tprintf("space_slots=%" PRI__u64 "}", args.space_slots);
Jeff Mahoney8cc69622016-05-18 18:09:39 -04001246 return 0;
1247 }
1248
1249 tprintf("total_spaces=%" PRI__u64, args.total_spaces);
1250
1251 if (args.space_slots == 0 && args.total_spaces) {
1252 tprints("}");
1253 break;
1254 }
1255
1256 tprints(", spaces=");
1257
1258 if (abbrev(tcp)) {
1259 tprints("...}");
1260 break;
1261 }
1262
1263 tprints("[");
1264
1265 for (i = 0; i < args.total_spaces; i++) {
1266 struct btrfs_ioctl_space_info info;
1267 uint64_t off = offsetof(typeof(args), spaces[i]);
1268 if (i)
1269 tprints(", ");
1270
1271 if (i > max_strlen ||
1272 umoven(tcp, arg + off, sizeof(info), &info)) {
1273 tprints("...");
1274 break;
1275 }
1276
1277 tprints("{flags=");
1278 printflags64(btrfs_space_info_flags, info.flags,
1279 "BTRFS_SPACE_INFO_???");
1280 tprintf(", total_bytes=%" PRI__u64
1281 ", used_bytes=%" PRI__u64 "}",
1282 info.total_bytes, info.used_bytes);
1283 }
1284 tprints("]}");
1285 break;
1286 }
1287
1288 case BTRFS_IOC_SNAP_CREATE:
1289 case BTRFS_IOC_RESIZE:
1290 case BTRFS_IOC_SCAN_DEV:
1291 case BTRFS_IOC_ADD_DEV:
1292 case BTRFS_IOC_RM_DEV:
1293 case BTRFS_IOC_SUBVOL_CREATE:
1294 case BTRFS_IOC_SNAP_DESTROY:
1295 case BTRFS_IOC_DEVICES_READY: { /* W */
1296 struct btrfs_ioctl_vol_args args;
1297
1298 tprints(", ");
1299 if (umove_or_printaddr(tcp, arg, &args))
1300 break;
1301
1302 tprintf("{fd=%" PRI__d64 ", name=", args.fd);
1303 print_quoted_string(args.name, sizeof(args.name),
1304 QUOTE_0_TERMINATED);
1305 tprints("}");
1306 break;
1307 }
1308
1309 case BTRFS_IOC_SNAP_CREATE_V2:
1310 case BTRFS_IOC_SUBVOL_CREATE_V2: { /* code is W, but is actually RW */
1311 struct btrfs_ioctl_vol_args_v2 args;
1312
1313 if (entering(tcp))
1314 tprints(", ");
1315 else if (syserror(tcp))
1316 break;
1317 else
1318 tprints(" => ");
1319
1320 if (umove_or_printaddr(tcp, arg, &args))
1321 break;
1322
1323 if (entering(tcp)) {
1324 tprintf("{fd=%" PRI__d64 ", flags=", args.fd);
1325 printflags64(btrfs_snap_flags_v2, args.flags,
1326 "BTRFS_SUBVOL_???");
1327 if (args.flags & BTRFS_SUBVOL_QGROUP_INHERIT) {
1328 tprintf(", size=%" PRI__u64 ", qgroup_inherit=",
1329 args.size);
1330
1331 btrfs_print_qgroup_inherit(tcp,
1332 (unsigned long)args.qgroup_inherit);
1333
1334 }
1335 tprintf(", name=");
1336 print_quoted_string(args.name,
1337 BTRFS_SUBVOL_NAME_MAX + 1,
1338 QUOTE_0_TERMINATED);
1339 tprints("}");
1340 return 0;
1341 }
1342 tprintf("{transid=%" PRI__u64 "}", args.transid);
1343 break;
1344 }
1345 case BTRFS_IOC_GET_FSLABEL: /* R */
1346 case BTRFS_IOC_SET_FSLABEL: {/* W */
1347 char label[BTRFS_LABEL_SIZE];
1348 if (code == BTRFS_IOC_GET_FSLABEL && entering(tcp))
1349 return 0;
1350
1351 tprints(", ");
1352 if (umoven_or_printaddr(tcp, arg, sizeof(label), label))
1353 break;
1354 print_quoted_string(label, sizeof(label), QUOTE_0_TERMINATED);
1355 break;
1356 }
1357
1358 case BTRFS_IOC_CLONE: /* FICLONE */
1359 case BTRFS_IOC_CLONE_RANGE: /* FICLONERANGE */
1360 case BTRFS_IOC_FILE_EXTENT_SAME: /* FIDEDUPERANGE */
1361 /*
1362 * FICLONE, FICLONERANGE, and FIDEDUPERANGE started out as
1363 * btrfs ioctls and the code was kept for the generic
1364 * implementations. We use the BTRFS_* names here because
1365 * they will be available on older systems.
1366 */
1367 return file_ioctl(tcp, code, arg);
1368
1369 default:
1370 return RVAL_DECODED;
1371 };
1372 return ret | RVAL_DECODED | 1;
1373}
1374#endif /* HAVE_LINUX_BTRFS_H */