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

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