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("{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 static void
 265 btrfs_print_key_type(uint32_t type)
 266 {
 267         tprintf("%u", type);
 268         tprints_comment(xlookup(btrfs_key_types, type));
 269 }
 270
 271 static void
 272 btrfs_print_objectid(uint64_t objectid)
 273 {
 274         tprintf("%" PRIu64, objectid);
 275         tprints_comment(xlookup(btrfs_tree_objectids, objectid));
 276 }
 277
 278 static void
 279 btrfs_print_data_container_header(const struct btrfs_data_container *container)
 280 {
 281         tprintf("{bytes_left=%u, bytes_missing=%u"
 282                 ", elem_cnt=%u, elem_missed=%u, val=",
 283                 container->bytes_left, container->bytes_missing,
 284                 container->elem_cnt, container->elem_missed);
 285 }
 286
 287 static void
 288 btrfs_print_data_container_footer(void)
 289 {
 290         tprints("}");
 291 }
 292
 293 static bool
 294 print_btrfs_data_container_logical_ino(struct tcb *tcp, void *elem_buf,
 295                                        size_t elem_size, void *data)
 296 {
 297         const uint64_t *const record = elem_buf;
 298
 299         tprintf("{inum=%" PRIu64 ", offset=%" PRIu64 ", root=%" PRIu64 "}",
 300                 record[0], record[1], record[2]);
 301
 302         return true;
 303 }
 304
 305 static void
 306 btrfs_print_logical_ino_container(struct tcb *tcp,
 307                                   const uint64_t inodes_addr)
 308 {
 309         struct btrfs_data_container container;
 310
 311         if (umove_or_printaddr(tcp, inodes_addr, &container))
 312                 return;
 313
 314         btrfs_print_data_container_header(&container);
 315
 316         if (abbrev(tcp)) {
 317                 tprints("...");
 318         } else {
 319                 const uint64_t val_addr =
 320                         inodes_addr + offsetof(typeof(container), val);
 321                 uint64_t record[3];
 322                 print_array(tcp, val_addr, container.elem_cnt / 3,
 323                             record, sizeof(record),
 324                             umoven_or_printaddr,
 325                             print_btrfs_data_container_logical_ino, 0);
 326         }
 327
 328         btrfs_print_data_container_footer();
 329 }
 330
 331 static bool
 332 print_btrfs_data_container_ino_path(struct tcb *tcp, void *elem_buf,
 333                                        size_t elem_size, void *data)
 334 {
 335         const uint64_t *const offset = elem_buf;
 336         const uint64_t *const val_addr = data;
 337
 338         printpath(tcp, *val_addr + *offset);
 339
 340         return true;
 341 }
 342
 343 static void
 344 btrfs_print_ino_path_container(struct tcb *tcp,
 345                                const uint64_t fspath_addr)
 346 {
 347         struct btrfs_data_container container;
 348
 349         if (umove_or_printaddr(tcp, fspath_addr, &container))
 350                 return;
 351
 352         btrfs_print_data_container_header(&container);
 353
 354         if (abbrev(tcp)) {
 355                 tprints("...");
 356         } else {
 357                 uint64_t val_addr =
 358                         fspath_addr + offsetof(typeof(container), val);
 359                 uint64_t offset;
 360                 print_array(tcp, val_addr, container.elem_cnt,
 361                             &offset, sizeof(offset),
 362                             umoven_or_printaddr,
 363                             print_btrfs_data_container_ino_path, &val_addr);
 364         }
 365
 366         btrfs_print_data_container_footer();
 367 }
 368
 369 static bool
 370 print_uint64(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
 371 {
 372         tprintf("%" PRIu64, *(uint64_t *) elem_buf);
 373
 374         return true;
 375 }
 376
 377 static void
 378 btrfs_print_qgroup_inherit(struct tcb *const tcp, const kernel_ulong_t qgi_addr)
 379 {
 380         struct btrfs_qgroup_inherit inherit;
 381
 382         if (umove_or_printaddr(tcp, qgi_addr, &inherit))
 383                 return;
 384
 385         tprints("{flags=");
 386         printflags64(btrfs_qgroup_inherit_flags, inherit.flags,
 387                      "BTRFS_QGROUP_INHERIT_???");
 388         tprintf(", num_qgroups=%" PRI__u64 ", num_ref_copies=%" PRI__u64
 389                 ", num_excl_copies=%" PRI__u64 ", lim=",
 390                 inherit.num_qgroups, inherit.num_ref_copies,
 391                 inherit.num_excl_copies);
 392
 393         btrfs_print_qgroup_limit(&inherit.lim);
 394
 395         tprints(", qgroups=");
 396
 397         if (abbrev(tcp)) {
 398                 tprints("...");
 399         } else {
 400                 uint64_t record;
 401                 print_array(tcp, qgi_addr + offsetof(typeof(inherit), qgroups),
 402                             inherit.num_qgroups, &record, sizeof(record),
 403                             umoven_or_printaddr, print_uint64, 0);
 404         }
 405         tprints("}");
 406 }
 407
 408 static void
 409 print_key_value_internal(struct tcb *tcp, const char *name, uint64_t value)
 410 {
 411         if (value) {
 412                 tprintf(", %s=%" PRIu64, name, value);
 413                 if (value == UINT64_MAX)
 414                         tprints_comment("UINT64_MAX");
 415         }
 416 }
 417 #define print_key_value(tcp, key, name)                                 \
 418         print_key_value_internal((tcp), #name, (key)->name)
 419
 420 static void
 421 btrfs_print_tree_search(struct tcb *tcp, struct btrfs_ioctl_search_key *key,
 422                         uint64_t buf_addr, uint64_t buf_size, bool print_size)
 423 {
 424         if (entering(tcp)) {
 425                 tprints("{key={tree_id=");
 426                 btrfs_print_objectid(key->tree_id);
 427
 428                 if (key->min_objectid != BTRFS_FIRST_FREE_OBJECTID ||
 429                     !abbrev(tcp)) {
 430                         tprints(", min_objectid=");
 431                         btrfs_print_objectid(key->min_objectid);
 432                 }
 433
 434                 if (key->max_objectid != BTRFS_LAST_FREE_OBJECTID ||
 435                     !abbrev(tcp)) {
 436                         tprints(", max_objectid=");
 437                         btrfs_print_objectid(key->max_objectid);
 438                 }
 439
 440                 print_key_value(tcp, key, min_offset);
 441                 print_key_value(tcp, key, max_offset);
 442                 print_key_value(tcp, key, min_transid);
 443                 print_key_value(tcp, key, max_transid);
 444
 445                 tprints(", min_type=");
 446                 btrfs_print_key_type(key->min_type);
 447                 tprints(", max_type=");
 448                 btrfs_print_key_type(key->max_type);
 449                 tprintf(", nr_items=%u}", key->nr_items);
 450                 if (print_size)
 451                         tprintf(", buf_size=%" PRIu64, buf_size);
 452                 tprints("}");
 453         } else {
 454                 tprintf("{key={nr_items=%u}", key->nr_items);
 455                 if (print_size)
 456                         tprintf(", buf_size=%" PRIu64, buf_size);
 457                 tprints(", buf=");
 458                 if (abbrev(tcp))
 459                         tprints("...");
 460                 else {
 461                         uint64_t i;
 462                         uint64_t off = 0;
 463                         tprints("[");
 464                         for (i = 0; i < key->nr_items; i++) {
 465                                 struct btrfs_ioctl_search_header sh;
 466                                 uint64_t addr = buf_addr + off;
 467                                 if (i)
 468                                         tprints(", ");
 469                                 if (i > max_strlen ||
 470                                     umove(tcp, addr, &sh)) {
 471                                         tprints("...");
 472                                         break;
 473                                 }
 474                                 tprintf("{transid=%" PRI__u64 ", objectid=",
 475                                         sh.transid);
 476                                 btrfs_print_objectid(sh.objectid);
 477                                 tprintf(", offset=%" PRI__u64 ", type=", sh.offset);
 478                                 btrfs_print_key_type(sh.type);
 479                                 tprintf(", len=%u}", sh.len);
 480                                 off += sizeof(sh) + sh.len;
 481
 482                         }
 483                         tprints("]");
 484                 }
 485                 tprints("}");
 486         }
 487 }
 488
 489 static bool
 490 print_objectid_callback(struct tcb *tcp, void *elem_buf,
 491                         size_t elem_size, void *data)
 492 {
 493         btrfs_print_objectid(*(uint64_t *) elem_buf);
 494
 495         return true;
 496 }
 497
 498 static bool
 499 print_btrfs_ioctl_space_info(struct tcb *tcp, void *elem_buf,
 500                              size_t elem_size, void *data)
 501 {
 502         const struct btrfs_ioctl_space_info *info = elem_buf;
 503
 504         tprints("{flags=");
 505         printflags64(btrfs_space_info_flags, info->flags,
 506                      "BTRFS_SPACE_INFO_???");
 507         tprintf(", total_bytes=%" PRI__u64 ", used_bytes=%" PRI__u64 "}",
 508                 info->total_bytes, info->used_bytes);
 509
 510         return true;
 511 }
 512
 513 MPERS_PRINTER_DECL(int, btrfs_ioctl,
 514                    struct tcb *const tcp, const unsigned int code,
 515                    const kernel_ulong_t arg)
 516 {
 517         switch (code) {
 518         /* Take no arguments; command only. */
 519         case BTRFS_IOC_TRANS_START:
 520         case BTRFS_IOC_TRANS_END:
 521         case BTRFS_IOC_SYNC:
 522         case BTRFS_IOC_SCRUB_CANCEL:
 523         case BTRFS_IOC_QUOTA_RESCAN_WAIT:
 524         /*
 525          * The codes for these ioctls are based on each accepting a
 526          * vol_args but none of them actually consume an argument.
 527          */
 528         case BTRFS_IOC_DEFRAG:
 529         case BTRFS_IOC_BALANCE:
 530                 break;
 531
 532         /* takes a signed int */
 533         case BTRFS_IOC_BALANCE_CTL:
 534                 tprints(", ");
 535                 printxval(btrfs_balance_ctl_cmds, arg, "BTRFS_BALANCE_CTL_???");
 536                 break;
 537
 538         /* returns a 64 */
 539         case BTRFS_IOC_START_SYNC: /* R */
 540                 if (entering(tcp))
 541                         return 0;
 542         ATTRIBUTE_FALLTHROUGH;
 543         /* takes a u64 */
 544         case BTRFS_IOC_DEFAULT_SUBVOL: /* W */
 545         case BTRFS_IOC_WAIT_SYNC: /* W */
 546                 tprints(", ");
 547                 printnum_int64(tcp, arg, "%" PRIu64);
 548                 break;
 549
 550         /* u64 but describe a flags bitfield; we can make that symbolic */
 551         case BTRFS_IOC_SUBVOL_GETFLAGS: { /* R */
 552                 uint64_t flags;
 553
 554                 if (entering(tcp))
 555                         return 0;
 556
 557                 tprints(", ");
 558
 559                 if (umove_or_printaddr(tcp, arg, &flags))
 560                         break;
 561
 562                 printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???");
 563                 break;
 564         }
 565
 566         case BTRFS_IOC_SUBVOL_SETFLAGS: { /* W */
 567                 uint64_t flags;
 568
 569                 tprints(", ");
 570
 571                 if (umove_or_printaddr(tcp, arg, &flags))
 572                         break;
 573
 574                 printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???");
 575                 break;
 576         }
 577
 578         /* More complex types */
 579         case BTRFS_IOC_BALANCE_V2: /* RW */
 580                 if (entering(tcp)) {
 581                         tprints(", ");
 582                         btrfs_print_balance(tcp, arg, false);
 583                         return 0;
 584                 }
 585
 586                 if (syserror(tcp))
 587                         break;
 588
 589                 tprints(" => ");
 590                 btrfs_print_balance(tcp, arg, true);
 591                 break;
 592         case BTRFS_IOC_BALANCE_PROGRESS: /* R */
 593                 if (entering(tcp))
 594                         return 0;
 595
 596                 tprints(", ");
 597                 btrfs_print_balance(tcp, arg, true);
 598                 break;
 599
 600         case BTRFS_IOC_DEFRAG_RANGE: { /* W */
 601                 struct btrfs_ioctl_defrag_range_args args;
 602
 603                 tprints(", ");
 604
 605                 if (umove_or_printaddr(tcp, arg, &args))
 606                         break;
 607
 608                 tprintf("{start=%" PRIu64 ", len=", (uint64_t)args.start);
 609
 610                 tprintf("%" PRIu64, (uint64_t) args.len);
 611                 if (args.len == UINT64_MAX)
 612                         tprints_comment("UINT64_MAX");
 613
 614                 tprints(", flags=");
 615                 printflags64(btrfs_defrag_flags, args.flags,
 616                              "BTRFS_DEFRAG_RANGE_???");
 617                 tprintf(", extent_thresh=%u, compress_type=",
 618                         args.extent_thresh);
 619                 printxval(btrfs_compress_types, args.compress_type,
 620                           "BTRFS_COMPRESS_???");
 621                 tprints("}");
 622                 break;
 623         }
 624
 625         case BTRFS_IOC_DEV_INFO: { /* RW */
 626                 struct btrfs_ioctl_dev_info_args args;
 627                 char uuid[UUID_STRING_SIZE+1];
 628                 int valid;
 629
 630                 if (entering(tcp))
 631                         tprints(", ");
 632                 else if (syserror(tcp))
 633                         break;
 634                 else
 635                         tprints(" => ");
 636                 if (umove_or_printaddr(tcp, arg, &args))
 637                         break;
 638                 tprints("{");
 639
 640                 valid = btrfs_unparse_uuid(args.uuid, uuid);
 641                 if (entering(tcp)) {
 642                         tprintf("devid=%" PRI__u64, args.devid);
 643                         if (valid)
 644                                 tprintf(", uuid=%s", uuid);
 645                         tprints("}");
 646                         return 0;
 647                 }
 648                 if (valid)
 649                         tprintf("uuid=%s, ", uuid);
 650                 tprintf("bytes_used=%" PRI__u64
 651                         ", total_bytes=%" PRI__u64,
 652                         args.bytes_used, args.total_bytes);
 653                 PRINT_FIELD_CSTRING(", ", args, path);
 654                 tprints("}");
 655                 break;
 656         }
 657
 658         case BTRFS_IOC_DEV_REPLACE: { /* RW */
 659                 struct_btrfs_ioctl_dev_replace_args args;
 660
 661                 if (entering(tcp))
 662                         tprints(", ");
 663                 else if (syserror(tcp))
 664                         break;
 665                 else
 666                         tprints(" => ");
 667
 668                 if (umove_or_printaddr(tcp, arg, &args))
 669                         break;
 670
 671                 if (entering(tcp)) {
 672                         tprints("{cmd=");
 673                         printxval64(btrfs_dev_replace_cmds, args.cmd,
 674                                     "BTRFS_IOCTL_DEV_REPLACE_CMD_???");
 675                         if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_START) {
 676                                 const char *str;
 677                                 tprintf(", start={srcdevid=%" PRIu64
 678                                    ", cont_reading_from_srcdev_mode=%" PRIu64
 679                                    ", srcdev_name=",
 680                                    (uint64_t) args.start.srcdevid,
 681                                    (uint64_t) args.start.cont_reading_from_srcdev_mode);
 682
 683                                 str = (const char *) args.start.srcdev_name;
 684                                 print_quoted_cstring(str,
 685                                                 sizeof(args.start.srcdev_name));
 686                                 tprints(", tgtdev_name=");
 687                                 str = (const char *) args.start.tgtdev_name;
 688                                 print_quoted_cstring(str,
 689                                                 sizeof(args.start.tgtdev_name));
 690                                 tprints("}");
 691
 692                         }
 693                         tprints("}");
 694                         return 0;
 695                 }
 696
 697                 tprints("{result=");
 698                 printxval64(btrfs_dev_replace_results, args.result,
 699                             "BTRFS_IOCTL_DEV_REPLACE_RESULT_???");
 700                 if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS) {
 701                         tprints(", ");
 702                         printxval64(btrfs_dev_replace_state,
 703                                    args.status.replace_state,
 704                                    "BTRFS_IOCTL_DEV_REPLACE_STATE_???");
 705                         tprintf(", progress_1000=%" PRIu64,
 706                                 (uint64_t) args.status.progress_1000);
 707
 708                         if (args.status.progress_1000 <= 1000)
 709                                 tprintf_comment("%u.%u%%",
 710                                         (unsigned) args.status.progress_1000 / 10,
 711                                         (unsigned) args.status.progress_1000 % 10);
 712
 713                         tprintf(", time_started=%" PRIu64,
 714                                 (uint64_t) args.status.time_started);
 715                         tprints_comment(sprinttime(args.status.time_started));
 716
 717                         tprintf(", time_stopped=%" PRIu64,
 718                                 (uint64_t) args.status.time_stopped);
 719                         tprints_comment(sprinttime(args.status.time_stopped));
 720
 721                         tprintf(", num_write_errors=%" PRIu64
 722                                 ", num_uncorrectable_read_errors=%" PRIu64,
 723                                 (uint64_t) args.status.num_write_errors,
 724                                 (uint64_t) args.status.num_uncorrectable_read_errors);
 725                 }
 726                 tprints("}");
 727                 break;
 728         }
 729
 730         case BTRFS_IOC_GET_FEATURES: { /* R */
 731                 struct btrfs_ioctl_feature_flags flags;
 732
 733                 if (entering(tcp))
 734                         return 0;
 735
 736                 tprints(", ");
 737                 if (umove_or_printaddr(tcp, arg, &flags))
 738                         break;
 739
 740                 btrfs_print_features(&flags);
 741                 break;
 742         }
 743
 744         case BTRFS_IOC_SET_FEATURES: { /* W */
 745                 struct btrfs_ioctl_feature_flags flarg[2];
 746
 747                 tprints(", ");
 748
 749                 if (umove_or_printaddr(tcp, arg, &flarg))
 750                         break;
 751
 752                 tprints("[");
 753                 btrfs_print_features(&flarg[0]);
 754                 tprints(", ");
 755                 btrfs_print_features(&flarg[1]);
 756                 tprints("]");
 757                 break;
 758         }
 759
 760         case BTRFS_IOC_GET_SUPPORTED_FEATURES: { /* R */
 761                 struct btrfs_ioctl_feature_flags flarg[3];
 762
 763                 if (entering(tcp))
 764                         return 0;
 765
 766                 tprints(", ");
 767                 if (umove_or_printaddr(tcp, arg, &flarg))
 768                         break;
 769
 770                 tprints("[");
 771                 btrfs_print_features(&flarg[0]);
 772                 tprints_comment("supported");
 773
 774                 tprints(", ");
 775                 btrfs_print_features(&flarg[1]);
 776                 tprints_comment("safe to set");
 777
 778                 tprints(", ");
 779                 btrfs_print_features(&flarg[2]);
 780                 tprints_comment("safe to clear");
 781                 tprints("]");
 782
 783                 break;
 784         }
 785
 786         case BTRFS_IOC_FS_INFO: { /* R */
 787                 struct btrfs_ioctl_fs_info_args args;
 788                 char uuid[UUID_STRING_SIZE+1];
 789                 uint32_t nodesize, sectorsize, clone_alignment;
 790 #ifndef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE
 791                 uint32_t *reserved32;
 792 #endif
 793
 794                 if (entering(tcp))
 795                         return 0;
 796
 797                 tprints(", ");
 798                 if (umove_or_printaddr(tcp, arg, &args))
 799                         break;
 800
 801 #ifdef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE
 802                 nodesize = args.nodesize,
 803                 sectorsize = args.sectorsize,
 804                 clone_alignment = args.clone_alignment;
 805 #else
 806                 reserved32 = (void *) args.reserved;
 807                 nodesize = reserved32[0];
 808                 sectorsize = reserved32[1];
 809                 clone_alignment = reserved32[2];
 810 #endif
 811                 btrfs_unparse_uuid(args.fsid, uuid);
 812
 813                 tprints("{");
 814                 tprintf("max_id=%" PRI__u64 ", num_devices=%" PRI__u64
 815                         ", fsid=%s, nodesize=%u, sectorsize=%u"
 816                         ", clone_alignment=%u",
 817                         args.max_id, args.num_devices, uuid,
 818                         nodesize, sectorsize, clone_alignment);
 819                 tprints("}");
 820                 break;
 821         }
 822
 823         case BTRFS_IOC_GET_DEV_STATS: { /* RW */
 824                 struct btrfs_ioctl_get_dev_stats args;
 825                 uint64_t i;
 826
 827                 if (entering(tcp))
 828                         tprints(", ");
 829                 else if (syserror(tcp))
 830                         break;
 831                 else
 832                         tprints(" => ");
 833                 if (umove_or_printaddr(tcp, arg, &args))
 834                         break;
 835
 836                 tprints("{");
 837
 838                 if (entering(tcp))
 839                         tprintf("devid=%" PRI__u64 ", ", args.devid);
 840
 841                 tprintf("nr_items=%" PRI__u64 ", flags=", args.nr_items);
 842                 printflags64(btrfs_dev_stats_flags, args.flags,
 843                              "BTRFS_DEV_STATS_???");
 844
 845                 if (entering(tcp)) {
 846                         tprints("}");
 847                         return 0;
 848                 }
 849
 850                 /*
 851                  * The structure has a 1k limit; Let's make sure we don't
 852                  * go off into the middle of nowhere with a bad nr_items
 853                  * value.
 854                  */
 855                 tprints(", [");
 856                 for (i = 0; i < args.nr_items; i++) {
 857                         if (i)
 858                                 tprints(", ");
 859                         if (i >= ARRAY_SIZE(args.values)) {
 860                                 tprints("...");
 861                                 break;
 862                         }
 863                         tprintf("%" PRI__u64, args.values[i]);
 864                         tprints_comment(xlookup(btrfs_dev_stats_values, i));
 865                 }
 866                 tprints("]}");
 867                 break;
 868         }
 869
 870         case BTRFS_IOC_INO_LOOKUP: { /* RW */
 871                 struct btrfs_ioctl_ino_lookup_args args;
 872
 873                 if (entering(tcp))
 874                         tprints(", ");
 875                 else if (syserror(tcp))
 876                         break;
 877                 else
 878                         tprints(" => ");
 879
 880                 if (umove_or_printaddr(tcp, arg, &args))
 881                         break;
 882
 883                 if (entering(tcp)) {
 884                         /* Use subvolume id of the containing root */
 885                         if (args.treeid == 0)
 886                                 set_tcb_priv_ulong(tcp, 1);
 887
 888                         tprints("{treeid=");
 889                         btrfs_print_objectid(args.treeid);
 890                         tprints(", objectid=");
 891                         btrfs_print_objectid(args.objectid);
 892                         tprints("}");
 893                         return 0;
 894                 }
 895
 896                 tprints("{");
 897                 if (get_tcb_priv_ulong(tcp)) {
 898                         tprints("treeid=");
 899                         btrfs_print_objectid(args.treeid);
 900                         tprints(", ");
 901                 }
 902
 903                 PRINT_FIELD_CSTRING("", args, name);
 904                 tprints("}");
 905                 break;
 906         }
 907
 908         case BTRFS_IOC_INO_PATHS: { /* RW */
 909                 struct btrfs_ioctl_ino_path_args args;
 910
 911                 if (entering(tcp))
 912                         tprints(", ");
 913                 else if (syserror(tcp))
 914                         break;
 915                 else
 916                         tprints(" => ");
 917
 918                 if (umove_or_printaddr(tcp, arg, &args))
 919                         break;
 920
 921                 tprints("{");
 922
 923                 if (entering(tcp)) {
 924                         tprintf("inum=%" PRI__u64 ", size=%" PRI__u64,
 925                                 args.inum, args.size);
 926                         tprints(", fspath=");
 927                         printaddr64(args.fspath);
 928                         tprints("}");
 929                         return 0;
 930                 }
 931
 932                 tprints("fspath=");
 933                 btrfs_print_ino_path_container(tcp, args.fspath);
 934
 935                 tprints("}");
 936                 break;
 937         }
 938
 939         case BTRFS_IOC_LOGICAL_INO: { /* RW */
 940                 struct btrfs_ioctl_logical_ino_args args;
 941
 942                 if (entering(tcp))
 943                         tprints(", ");
 944                 else if (syserror(tcp))
 945                         break;
 946                 else
 947                         tprints(" => ");
 948
 949                 if (umove_or_printaddr(tcp, arg, &args))
 950                         break;
 951
 952                 tprints("{");
 953
 954                 if (entering(tcp)) {
 955                         tprintf("logical=%" PRI__u64 ", size=%" PRI__u64,
 956                                 args.logical, args.size);
 957
 958                         tprintf(", flags=");
 959                         printflags64(btrfs_logical_ino_args_flags,
 960 #ifdef HAVE_STRUCT_BTRFS_IOCTL_LOGICAL_INO_ARGS_FLAGS
 961                                      args.flags
 962 #else
 963                                      args.reserved[3]
 964 #endif
 965                                      , "BTRFS_LOGICAL_INO_ARGS_???");
 966                         tprints(", inodes=");
 967                         printaddr64(args.inodes);
 968                         tprints("}");
 969                         return 0;
 970                 }
 971
 972                 tprints("inodes=");
 973                 btrfs_print_logical_ino_container(tcp, args.inodes);
 974
 975                 tprints("}");
 976                 break;
 977         }
 978
 979         case BTRFS_IOC_QGROUP_ASSIGN: { /* W */
 980                 struct btrfs_ioctl_qgroup_assign_args args;
 981
 982                 tprints(", ");
 983                 if (umove_or_printaddr(tcp, arg, &args))
 984                         break;
 985
 986                 tprintf("{assign=%" PRI__u64 ", src=%" PRI__u64
 987                         ", dst=%" PRI__u64 "}",
 988                         args.assign, args.src, args.dst);
 989                 break;
 990         }
 991
 992         case BTRFS_IOC_QGROUP_CREATE: { /* W */
 993                 struct btrfs_ioctl_qgroup_create_args args;
 994
 995                 tprints(", ");
 996                 if (umove_or_printaddr(tcp, arg, &args))
 997                         break;
 998
 999                 tprintf("{create=%" PRI__u64 ", qgroupid=%" PRI__u64 "}",
1000                         args.create, args.qgroupid);
1001                 break;
1002         }
1003
1004         case BTRFS_IOC_QGROUP_LIMIT: { /* R */
1005                 struct btrfs_ioctl_qgroup_limit_args args;
1006
1007                 if (entering(tcp))
1008                         return 0;
1009
1010                 tprints(", ");
1011                 if (umove_or_printaddr(tcp, arg, &args))
1012                         break;
1013
1014                 tprintf("{qgroupid=%" PRI__u64 ", lim=", args.qgroupid);
1015                 btrfs_print_qgroup_limit(&args.lim);
1016                 tprints("}");
1017                 break;
1018         }
1019
1020         case BTRFS_IOC_QUOTA_CTL: { /* W */
1021                 struct btrfs_ioctl_quota_ctl_args args;
1022
1023                 tprints(", ");
1024                 if (umove_or_printaddr(tcp, arg, &args))
1025                         break;
1026
1027                 printxval64(btrfs_qgroup_ctl_cmds, args.cmd,
1028                             "BTRFS_QUOTA_CTL_???");
1029                 tprints("}");
1030
1031                 break;
1032         }
1033
1034         case BTRFS_IOC_QUOTA_RESCAN: { /* W */
1035                 struct btrfs_ioctl_quota_rescan_args args;
1036
1037                 tprints(", ");
1038                 if (umove_or_printaddr(tcp, arg, &args))
1039                         break;
1040
1041                 tprintf("{flags=%" PRIu64 "}", (uint64_t) args.flags);
1042                 break;
1043         }
1044
1045         case BTRFS_IOC_QUOTA_RESCAN_STATUS: { /* R */
1046                 struct btrfs_ioctl_quota_rescan_args args;
1047
1048                 if (entering(tcp))
1049                         return 0;
1050
1051                 tprints(", ");
1052                 if (umove_or_printaddr(tcp, arg, &args))
1053                         break;
1054
1055                 tprintf("{flags=%" PRIu64 ", progress=", (uint64_t) args.flags);
1056                 btrfs_print_objectid(args.progress);
1057                 tprints("}");
1058                 break;
1059         }
1060
1061         case BTRFS_IOC_SET_RECEIVED_SUBVOL: { /* RW */
1062                 struct_btrfs_ioctl_received_subvol_args args;
1063                 char uuid[UUID_STRING_SIZE+1];
1064
1065                 if (entering(tcp))
1066                         tprints(", ");
1067                 else if (syserror(tcp))
1068                         break;
1069                 else
1070                         tprints(" => ");
1071
1072                 if (umove_or_printaddr(tcp, arg, &args))
1073                         break;
1074
1075                 if (entering(tcp)) {
1076                         btrfs_unparse_uuid((unsigned char *)args.uuid, uuid);
1077                         tprintf("{uuid=%s, stransid=%" PRIu64
1078                                 ", stime=%" PRIu64 ".%u, flags=%" PRIu64
1079                                 "}", uuid, (uint64_t) args.stransid,
1080                                 (uint64_t) args.stime.sec, args.stime.nsec,
1081                                 (uint64_t) args.flags);
1082                         return 0;
1083                 }
1084                 tprintf("{rtransid=%" PRIu64 ", rtime=%" PRIu64 ".%u}",
1085                         (uint64_t) args.rtransid, (uint64_t) args.rtime.sec,
1086                         args.rtime.nsec);
1087                 break;
1088         }
1089
1090         case BTRFS_IOC_SCRUB: /* RW */
1091         case BTRFS_IOC_SCRUB_PROGRESS: { /* RW */
1092                 struct btrfs_ioctl_scrub_args args;
1093
1094                 if (entering(tcp))
1095                         tprints(", ");
1096                 else if (syserror(tcp))
1097                         break;
1098                 else
1099                         tprints(" => ");
1100
1101                 if (umove_or_printaddr(tcp, arg, &args))
1102                         break;
1103
1104                 if (entering(tcp)) {
1105                         tprintf("{devid=%" PRI__u64, args.devid);
1106                         if (code == BTRFS_IOC_SCRUB) {
1107                                 tprintf(", start=%" PRI__u64 ", end=",
1108                                         args.start);
1109                                 tprintf("%" PRI__u64, args.end);
1110                                 if (args.end == UINT64_MAX)
1111                                         tprints_comment("UINT64_MAX");
1112                                 tprints(", flags=");
1113                                 printflags64(btrfs_scrub_flags, args.flags,
1114                                              "BTRFS_SCRUB_???");
1115                         }
1116                         tprints("}");
1117                         return 0;
1118                 }
1119                 tprintf("{data_extents_scrubbed=%" PRI__u64
1120                         ", tree_extents_scrubbed=%" PRI__u64
1121                         ", data_bytes_scrubbed=%" PRI__u64
1122                         ", tree_bytes_scrubbed=%" PRI__u64
1123                         ", read_errors=%" PRI__u64
1124                         ", csum_errors=%" PRI__u64
1125                         ", verify_errors=%" PRI__u64
1126                         ", no_csum=%" PRI__u64
1127                         ", csum_discards=%" PRI__u64
1128                         ", super_errors=%" PRI__u64
1129                         ", malloc_errors=%" PRI__u64
1130                         ", uncorrectable_errors=%" PRI__u64
1131                         ", corrected_errors=%" PRI__u64
1132                         ", last_physical=%" PRI__u64
1133                         ", unverified_errors=%" PRI__u64 "}",
1134                         args.progress.data_extents_scrubbed,
1135                         args.progress.tree_extents_scrubbed,
1136                         args.progress.data_bytes_scrubbed,
1137                         args.progress.tree_bytes_scrubbed,
1138                         args.progress.read_errors,
1139                         args.progress.csum_errors,
1140                         args.progress.verify_errors,
1141                         args.progress.no_csum,
1142                         args.progress.csum_discards,
1143                         args.progress.super_errors,
1144                         args.progress.malloc_errors,
1145                         args.progress.uncorrectable_errors,
1146                         args.progress.corrected_errors,
1147                         args.progress.last_physical,
1148                         args.progress.unverified_errors);
1149                 break;
1150         }
1151
1152         case BTRFS_IOC_TREE_SEARCH: { /* RW */
1153                 struct btrfs_ioctl_search_args args;
1154                 uint64_t buf_offset;
1155
1156                 if (entering(tcp))
1157                         tprints(", ");
1158                 else if (syserror(tcp))
1159                         break;
1160                 else
1161                         tprints(" => ");
1162
1163                 if (umove_or_printaddr(tcp, arg, &args))
1164                         break;
1165
1166                 buf_offset = offsetof(struct btrfs_ioctl_search_args, buf);
1167                 btrfs_print_tree_search(tcp, &args.key, arg + buf_offset,
1168                                         sizeof(args.buf), false);
1169                 if (entering(tcp))
1170                         return 0;
1171                 break;
1172         }
1173
1174         case BTRFS_IOC_TREE_SEARCH_V2: { /* RW */
1175                 struct btrfs_ioctl_search_args_v2 args;
1176                 uint64_t buf_offset;
1177
1178                 if (entering(tcp))
1179                         tprints(", ");
1180                 else if (syserror(tcp)) {
1181                         if (tcp->u_error == EOVERFLOW) {
1182                                 tprints(" => ");
1183                                 tcp->u_error = 0;
1184                                 if (!umove_or_printaddr(tcp, arg, &args))
1185                                         tprintf("{buf_size=%" PRIu64 "}",
1186                                                 (uint64_t)args.buf_size);
1187                                 tcp->u_error = EOVERFLOW;
1188                         }
1189                         break;
1190                 } else
1191                         tprints(" => ");
1192
1193                 if (umove_or_printaddr(tcp, arg, &args))
1194                         break;
1195
1196                 buf_offset = offsetof(struct btrfs_ioctl_search_args_v2, buf);
1197                 btrfs_print_tree_search(tcp, &args.key, arg + buf_offset,
1198                                         args.buf_size, true);
1199                 if (entering(tcp))
1200                         return 0;
1201                 break;
1202         }
1203
1204         case BTRFS_IOC_SEND: { /* W */
1205                 struct_btrfs_ioctl_send_args args;
1206
1207                 tprints(", ");
1208                 if (umove_or_printaddr(tcp, arg, &args))
1209                         break;
1210
1211                 tprints("{send_fd=");
1212                 printfd(tcp, args.send_fd);
1213                 tprintf(", clone_sources_count=%" PRIu64 ", clone_sources=",
1214                         (uint64_t) args.clone_sources_count);
1215
1216                 if (abbrev(tcp))
1217                         tprints("...");
1218                 else {
1219                         uint64_t record;
1220                         print_array(tcp, ptr_to_kulong(args.clone_sources),
1221                                     args.clone_sources_count,
1222                                     &record, sizeof(record),
1223                                     umoven_or_printaddr,
1224                                     print_objectid_callback, 0);
1225                 }
1226                 tprints(", parent_root=");
1227                 btrfs_print_objectid(args.parent_root);
1228                 tprints(", flags=");
1229                 printflags64(btrfs_send_flags, args.flags,
1230                              "BTRFS_SEND_FLAGS_???");
1231                 tprints("}");
1232                 break;
1233         }
1234
1235         case BTRFS_IOC_SPACE_INFO: { /* RW */
1236                 struct btrfs_ioctl_space_args args;
1237
1238                 if (entering(tcp))
1239                         tprints(", ");
1240                 else if (syserror(tcp))
1241                         break;
1242                 else
1243                         tprints(" => ");
1244
1245                 if (umove_or_printaddr(tcp, arg, &args))
1246                         break;
1247
1248                 tprints("{");
1249                 if (entering(tcp)) {
1250                         tprintf("space_slots=%" PRI__u64 "}", args.space_slots);
1251                         return 0;
1252                 }
1253
1254                 tprintf("total_spaces=%" PRI__u64, args.total_spaces);
1255
1256                 if (args.space_slots == 0 && args.total_spaces) {
1257                         tprints("}");
1258                         break;
1259                 }
1260
1261                 tprints(", spaces=");
1262
1263                 if (abbrev(tcp))
1264                         tprints("...");
1265                 else {
1266                         struct btrfs_ioctl_space_info info;
1267                         print_array(tcp, arg + offsetof(typeof(args), spaces),
1268                                     args.total_spaces,
1269                                     &info, sizeof(info), umoven_or_printaddr,
1270                                     print_btrfs_ioctl_space_info, 0);
1271                 }
1272                 tprints("}");
1273                 break;
1274         }
1275
1276         case BTRFS_IOC_SNAP_CREATE:
1277         case BTRFS_IOC_RESIZE:
1278         case BTRFS_IOC_SCAN_DEV:
1279         case BTRFS_IOC_ADD_DEV:
1280         case BTRFS_IOC_RM_DEV:
1281         case BTRFS_IOC_SUBVOL_CREATE:
1282         case BTRFS_IOC_SNAP_DESTROY:
1283         case BTRFS_IOC_DEVICES_READY: { /* W */
1284                 struct btrfs_ioctl_vol_args args;
1285
1286                 tprints(", ");
1287                 if (umove_or_printaddr(tcp, arg, &args))
1288                         break;
1289
1290                 tprints("{fd=");
1291                 printfd(tcp, args.fd);
1292                 PRINT_FIELD_CSTRING(", ", args, name);
1293                 tprints("}");
1294                 break;
1295         }
1296
1297         case BTRFS_IOC_SNAP_CREATE_V2:
1298         case BTRFS_IOC_SUBVOL_CREATE_V2: { /* code is W, but is actually RW */
1299                 struct_btrfs_ioctl_vol_args_v2 args;
1300
1301                 if (entering(tcp))
1302                         tprints(", ");
1303                 else if (syserror(tcp))
1304                         break;
1305                 else
1306                         tprints(" => ");
1307
1308                 if (umove_or_printaddr(tcp, arg, &args))
1309                         break;
1310
1311                 if (entering(tcp)) {
1312                         tprints("{fd=");
1313                         printfd(tcp, args.fd);
1314                         tprints(", flags=");
1315                         printflags64(btrfs_snap_flags_v2, args.flags,
1316                                      "BTRFS_SUBVOL_???");
1317                         if (args.flags & BTRFS_SUBVOL_QGROUP_INHERIT) {
1318                                 tprintf(", size=%" PRIu64 ", qgroup_inherit=",
1319                                         (uint64_t) args.size);
1320
1321                                 btrfs_print_qgroup_inherit(tcp,
1322                                         ptr_to_kulong(args.qgroup_inherit));
1323                         }
1324                         PRINT_FIELD_CSTRING(", ", args, name);
1325                         tprints("}");
1326                         return 0;
1327                 }
1328                 tprintf("{transid=%" PRIu64 "}", (uint64_t) args.transid);
1329                 break;
1330         }
1331
1332         case BTRFS_IOC_GET_FSLABEL: /* R */
1333                 if (entering(tcp))
1334                         return 0;
1335                 ATTRIBUTE_FALLTHROUGH;
1336         case BTRFS_IOC_SET_FSLABEL: { /* W */
1337                 char label[BTRFS_LABEL_SIZE];
1338
1339                 tprints(", ");
1340                 if (umove_or_printaddr(tcp, arg, &label))
1341                         break;
1342                 print_quoted_cstring(label, sizeof(label));
1343                 break;
1344         }
1345
1346         case BTRFS_IOC_CLONE:                   /* FICLONE */
1347         case BTRFS_IOC_CLONE_RANGE:             /* FICLONERANGE */
1348 #ifdef BTRFS_IOC_FILE_EXTENT_SAME
1349         case BTRFS_IOC_FILE_EXTENT_SAME:        /* FIDEDUPERANGE */
1350 #endif
1351                 /*
1352                  * FICLONE, FICLONERANGE, and FIDEDUPERANGE started out as
1353                  * btrfs ioctls and the code was kept for the generic
1354                  * implementations.  We use the BTRFS_* names here because
1355                  * they will be available on older systems.
1356                  */
1357                 return file_ioctl(tcp, code, arg);
1358
1359         default:
1360                 return RVAL_DECODED;
1361         };
1362         return RVAL_IOCTL_DECODED;
1363 }
1364 #endif /* HAVE_LINUX_BTRFS_H */