granicus.if.org Git - strace/blob - btrfs.c

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