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
  36 # include <linux/btrfs.h>
  37
  38 typedef struct btrfs_ioctl_dev_replace_args
  39         struct_btrfs_ioctl_dev_replace_args;
  40 typedef struct btrfs_ioctl_send_args
  41         struct_btrfs_ioctl_send_args;
  42 typedef struct btrfs_ioctl_received_subvol_args
  43         struct_btrfs_ioctl_received_subvol_args;
  44
  45 #endif /* HAVE_LINUX_BTRFS_H */
  46
  47 #include MPERS_DEFS
  48
  49 #ifdef HAVE_LINUX_BTRFS_H
  50
  51 #include <linux/fs.h>
  52
  53 /*
  54  * Prior to Linux 3.12, the BTRFS_IOC_DEFAULT_SUBVOL used u64 in
  55  * its definition, which isn't exported by the kernel.
  56  */
  57 typedef __u64 u64;
  58
  59 #ifndef HAVE_STRUCT_BTRFS_IOCTL_FEATURE_FLAGS_COMPAT_FLAGS
  60 struct btrfs_ioctl_feature_flags {
  61         uint64_t compat_flags;
  62         uint64_t compat_ro_flags;
  63         uint64_t incompat_flags;
  64 };
  65 #endif
  66
  67 #ifndef HAVE_STRUCT_BTRFS_IOCTL_DEFRAG_RANGE_ARGS_START
  68 struct btrfs_ioctl_defrag_range_args {
  69         uint64_t start;
  70         uint64_t len;
  71         uint64_t flags;
  72         uint32_t extent_thresh;
  73         uint32_t compress_type;
  74         uint32_t unused[4];
  75 };
  76 #endif
  77
  78 #ifndef BTRFS_LABEL_SIZE
  79 # define BTRFS_LABEL_SIZE 256
  80 #endif
  81
  82 #ifndef BTRFS_FIRST_FREE_OBJECTID
  83 # define BTRFS_FIRST_FREE_OBJECTID 256ULL
  84 #endif
  85
  86 #ifndef BTRFS_IOC_QUOTA_RESCAN
  87 struct btrfs_ioctl_quota_rescan_args {
  88         uint64_t flags, progress, reserved[6];
  89 };
  90 # define BTRFS_IOC_QUOTA_RESCAN _IOW(BTRFS_IOCTL_MAGIC, 44, \
  91                                         struct btrfs_ioctl_quota_rescan_args)
  92 # define BTRFS_IOC_QUOTA_RESCAN_STATUS _IOR(BTRFS_IOCTL_MAGIC, 45, \
  93                                         struct btrfs_ioctl_quota_rescan_args)
  94 #endif
  95
  96 #ifndef BTRFS_IOC_QUOTA_RESCAN_WAIT
  97 # define BTRFS_IOC_QUOTA_RESCAN_WAIT _IO(BTRFS_IOCTL_MAGIC, 46)
  98 #endif
  99
 100 #ifndef BTRFS_IOC_GET_FEATURES
 101 # define BTRFS_IOC_GET_FEATURES _IOR(BTRFS_IOCTL_MAGIC, 57, \
 102                                         struct btrfs_ioctl_feature_flags)
 103 # define BTRFS_IOC_SET_FEATURES _IOW(BTRFS_IOCTL_MAGIC, 57, \
 104                                         struct btrfs_ioctl_feature_flags[2])
 105 # define BTRFS_IOC_GET_SUPPORTED_FEATURES _IOR(BTRFS_IOCTL_MAGIC, 57, \
 106                                         struct btrfs_ioctl_feature_flags[3])
 107 #endif
 108
 109 #ifndef BTRFS_IOC_TREE_SEARCH_V2
 110 # define BTRFS_IOC_TREE_SEARCH_V2 _IOWR(BTRFS_IOCTL_MAGIC, 17, \
 111                                         struct btrfs_ioctl_search_args_v2)
 112 struct btrfs_ioctl_search_args_v2 {
 113         struct btrfs_ioctl_search_key key; /* in/out - search parameters */
 114         uint64_t buf_size;                 /* in - size of buffer
 115                                             * out - on EOVERFLOW: needed size
 116                                             *       to store item */
 117         uint64_t buf[0];                   /* out - found items */
 118 };
 119 #endif
 120
 121 #include "xlat/btrfs_balance_args.h"
 122 #include "xlat/btrfs_balance_ctl_cmds.h"
 123 #include "xlat/btrfs_balance_flags.h"
 124 #include "xlat/btrfs_balance_state.h"
 125 #include "xlat/btrfs_compress_types.h"
 126 #include "xlat/btrfs_defrag_flags.h"
 127 #include "xlat/btrfs_dev_replace_cmds.h"
 128 #include "xlat/btrfs_dev_replace_results.h"
 129 #include "xlat/btrfs_dev_replace_state.h"
 130 #include "xlat/btrfs_dev_stats_flags.h"
 131 #include "xlat/btrfs_dev_stats_values.h"
 132 #include "xlat/btrfs_features_compat.h"
 133 #include "xlat/btrfs_features_compat_ro.h"
 134 #include "xlat/btrfs_features_incompat.h"
 135 #include "xlat/btrfs_key_types.h"
 136 #include "xlat/btrfs_qgroup_ctl_cmds.h"
 137 #include "xlat/btrfs_qgroup_inherit_flags.h"
 138 #include "xlat/btrfs_qgroup_limit_flags.h"
 139 #include "xlat/btrfs_qgroup_status_flags.h"
 140 #include "xlat/btrfs_scrub_flags.h"
 141 #include "xlat/btrfs_send_flags.h"
 142 #include "xlat/btrfs_snap_flags_v2.h"
 143 #include "xlat/btrfs_space_info_flags.h"
 144 #include "xlat/btrfs_tree_objectids.h"
 145
 146 static inline char
 147 prnibble(char v)
 148 {
 149         if (v >= 10)
 150                 return 'a' + (v - 10);
 151         return '0' + v;
 152 }
 153
 154 /* 8-4-4-4-12 = 36 characters */
 155 #define UUID_STRING_SIZE 36
 156
 157 /* Formats uuid, returns 0 if it's all zeroes */
 158 static int
 159 btrfs_unparse_uuid(unsigned char *uuid, char *out)
 160 {
 161         int i;
 162         int ret = 0;
 163         for (i = 0; i < BTRFS_UUID_SIZE; i++) {
 164                 if (i == 4 || i == 6 || i == 8 || i == 10)
 165                         *out++ = '-';
 166                 *out++ = prnibble(uuid[i] >> 4);
 167                 *out++ = prnibble(uuid[i] & 0xf);
 168                 if (uuid[i])
 169                         ret = 1;
 170         }
 171         *out = '\0';
 172         return ret;
 173 }
 174
 175 static void
 176 print_u64(const char *name, uint64_t value)
 177 {
 178         tprintf(", %s=%" PRIu64, name, value);
 179         if (value == UINT64_MAX)
 180                 tprints(" /* UINT64_MAX */");
 181 }
 182
 183 #define print_member_u64(obj, name) print_u64(#name, obj->name)
 184
 185 static void
 186 btrfs_print_balance_args(const char *name, const struct btrfs_balance_args *bba)
 187 {
 188         tprintf(", %s={profiles=", name);
 189         printflags64(btrfs_space_info_flags, bba->profiles,
 190                      "BTRFS_BLOCK_GROUP_???");
 191         print_member_u64(bba, usage);
 192         print_member_u64(bba, devid);
 193         print_member_u64(bba, pstart);
 194         print_member_u64(bba, pend);
 195         print_member_u64(bba, vstart);
 196         print_member_u64(bba, vend);
 197         print_member_u64(bba, target);
 198         tprints(", flags=");
 199         printflags64(btrfs_balance_args, bba->flags, "BTRFS_BALANCE_ARGS_???");
 200         tprints("}");
 201 }
 202
 203 static void
 204 btrfs_print_balance(struct tcb *tcp, const long arg, bool out)
 205 {
 206         struct btrfs_ioctl_balance_args balance_args;
 207
 208         if (umove_or_printaddr(tcp, arg, &balance_args))
 209                 return;
 210
 211         tprints("{flags=");
 212         printflags64(btrfs_balance_flags, balance_args.flags,
 213                      "BTRFS_BALANCE_???");
 214         if (out) {
 215                 tprints(", state=");
 216                 printflags64(btrfs_balance_state, balance_args.state,
 217                              "BTRFS_BALANCE_STATE_???");
 218         }
 219
 220         if (balance_args.flags & BTRFS_BALANCE_DATA)
 221                 btrfs_print_balance_args("data", &balance_args.data);
 222         if (balance_args.flags & BTRFS_BALANCE_METADATA)
 223                 btrfs_print_balance_args("meta", &balance_args.meta);
 224         if (balance_args.flags & BTRFS_BALANCE_SYSTEM)
 225                 btrfs_print_balance_args("sys", &balance_args.sys);
 226         tprints("}");
 227 }
 228
 229 static void
 230 btrfs_print_features(const struct btrfs_ioctl_feature_flags *flags)
 231 {
 232         tprints("{compat_flags=");
 233         printflags64(btrfs_features_compat, flags->compat_flags,
 234                      "BTRFS_FEATURE_COMPAT_???");
 235
 236         tprints(", compat_ro_flags=");
 237         printflags64(btrfs_features_compat_ro, flags->compat_ro_flags,
 238                      "BTRFS_FEATURE_COMPAT_RO_???");
 239
 240         tprints(", incompat_flags=");
 241         printflags64(btrfs_features_incompat, flags->incompat_flags,
 242                      "BTRFS_FEATURE_INCOMPAT_???");
 243         tprints("}");
 244 }
 245
 246 static void
 247 btrfs_print_qgroup_limit(const struct btrfs_qgroup_limit *lim)
 248 {
 249         tprints("{flags=");
 250         printflags64(btrfs_qgroup_limit_flags, lim->flags,
 251                      "BTRFS_QGROUP_LIMIT_???");
 252         tprintf(", max_rfer=%" PRI__u64 ", max_excl=%" PRI__u64
 253                 ", rsv_rfer=%" PRI__u64 ", rsv_excl=%" PRI__u64 "}",
 254                 lim->max_rfer, lim->max_excl,
 255                 lim->rsv_rfer, lim->rsv_excl);
 256 }
 257
 258 static void
 259 btrfs_print_key_type(uint32_t type)
 260 {
 261         const char *str = xlookup(btrfs_key_types, type);
 262         tprintf("%u", type);
 263         if (str)
 264                 tprintf(" /* %s */", str);
 265 }
 266
 267 static void
 268 btrfs_print_objectid(uint64_t objectid)
 269 {
 270         const char *str = xlookup(btrfs_tree_objectids, objectid);
 271         tprintf("%" PRIu64, objectid);
 272         if (str)
 273                 tprintf(" /* %s */", str);
 274 }
 275
 276 static void
 277 btrfs_print_data_container_header(const struct btrfs_data_container *container)
 278 {
 279         tprintf("{bytes_left=%u, bytes_missing=%u"
 280                 ", elem_cnt=%u, elem_missed=%u, val=",
 281                 container->bytes_left, container->bytes_missing,
 282                 container->elem_cnt, container->elem_missed);
 283 }
 284
 285 static void
 286 btrfs_print_data_container_footer(void)
 287 {
 288         tprints("}");
 289 }
 290
 291 static bool
 292 print_btrfs_data_container_logical_ino(struct tcb *tcp, void *elem_buf,
 293                                        size_t elem_size, void *data)
 294 {
 295         const uint64_t *const record = elem_buf;
 296
 297         tprintf("{inum=%" PRIu64 ", offset=%" PRIu64 ", root=%" PRIu64 "}",
 298                 record[0], record[1], record[2]);
 299
 300         return true;
 301 }
 302
 303 static void
 304 btrfs_print_logical_ino_container(struct tcb *tcp,
 305                                   const uint64_t inodes_addr)
 306 {
 307         struct btrfs_data_container container;
 308
 309         if (umove_or_printaddr(tcp, inodes_addr, &container))
 310                 return;
 311
 312         btrfs_print_data_container_header(&container);
 313
 314         if (abbrev(tcp)) {
 315                 tprints("...");
 316         } else {
 317                 const uint64_t val_addr =
 318                         inodes_addr + offsetof(typeof(container), val);
 319                 uint64_t record[3];
 320                 print_array(tcp, val_addr, container.elem_cnt / 3,
 321                             record, sizeof(record),
 322                             umoven_or_printaddr,
 323                             print_btrfs_data_container_logical_ino, 0);
 324         }
 325
 326         btrfs_print_data_container_footer();
 327 }
 328
 329 static bool
 330 print_btrfs_data_container_ino_path(struct tcb *tcp, void *elem_buf,
 331                                        size_t elem_size, void *data)
 332 {
 333         const uint64_t *const offset = elem_buf;
 334         const uint64_t *const val_addr = data;
 335
 336         printpath(tcp, *val_addr + *offset);
 337
 338         return true;
 339 }
 340
 341 static void
 342 btrfs_print_ino_path_container(struct tcb *tcp,
 343                                const uint64_t fspath_addr)
 344 {
 345         struct btrfs_data_container container;
 346
 347         if (umove_or_printaddr(tcp, fspath_addr, &container))
 348                 return;
 349
 350         btrfs_print_data_container_header(&container);
 351
 352         if (abbrev(tcp)) {
 353                 tprints("...");
 354         } else {
 355                 uint64_t val_addr =
 356                         fspath_addr + offsetof(typeof(container), val);
 357                 uint64_t offset;
 358                 print_array(tcp, val_addr, container.elem_cnt,
 359                             &offset, sizeof(offset),
 360                             umoven_or_printaddr,
 361                             print_btrfs_data_container_ino_path, &val_addr);
 362         }
 363
 364         btrfs_print_data_container_footer();
 365 }
 366
 367 static bool
 368 print_uint64(struct tcb *tcp, void *elem_buf, size_t elem_size, void *data)
 369 {
 370         tprintf("%" PRIu64, * (uint64_t *) elem_buf);
 371
 372         return true;
 373 }
 374
 375 static void
 376 btrfs_print_qgroup_inherit(struct tcb *tcp, const uint64_t qgi_addr)
 377 {
 378         struct btrfs_qgroup_inherit inherit;
 379
 380         if (umove_or_printaddr(tcp, qgi_addr, &inherit))
 381                 return;
 382
 383         tprintf("{flags=");
 384         printflags64(btrfs_qgroup_inherit_flags, inherit.flags,
 385                      "BTRFS_QGROUP_INHERIT_???");
 386         tprintf(", num_qgroups=%" PRI__u64 ", num_ref_copies=%" PRI__u64
 387                 ", num_excl_copies=%" PRI__u64 ", lim=",
 388                 inherit.num_qgroups, inherit.num_ref_copies,
 389                 inherit.num_excl_copies);
 390
 391         btrfs_print_qgroup_limit(&inherit.lim);
 392
 393         tprints(", qgroups=");
 394
 395         if (abbrev(tcp)) {
 396                 tprints("...");
 397         } else {
 398                 uint64_t record;
 399                 print_array(tcp, qgi_addr + offsetof(typeof(inherit), qgroups),
 400                             inherit.num_qgroups, &record, sizeof(record),
 401                             umoven_or_printaddr, print_uint64, 0);
 402         }
 403         tprints("}");
 404 }
 405
 406 static void
 407 print_key_value_internal(struct tcb *tcp, const char *name, uint64_t value)
 408 {
 409         if (value) {
 410                 tprintf(", %s=%" PRIu64, name, value);
 411                 if (value == UINT64_MAX)
 412                         tprints(" /* UINT64_MAX */");
 413         }
 414 }
 415 #define print_key_value(tcp, key, name)                                 \
 416         print_key_value_internal((tcp), #name, (key)->name)
 417
 418 static void
 419 btrfs_print_tree_search(struct tcb *tcp, struct btrfs_ioctl_search_key *key,
 420                         uint64_t buf_addr, uint64_t buf_size, bool print_size)
 421 {
 422         if (entering(tcp)) {
 423                 tprintf("{key={tree_id=");
 424                 btrfs_print_objectid(key->tree_id);
 425
 426                 if (key->min_objectid != BTRFS_FIRST_FREE_OBJECTID ||
 427                     !abbrev(tcp)) {
 428                         tprints(", min_objectid=");
 429                         btrfs_print_objectid(key->min_objectid);
 430                 }
 431
 432                 if (key->max_objectid != BTRFS_LAST_FREE_OBJECTID ||
 433                     !abbrev(tcp)) {
 434                         tprints(", max_objectid=");
 435                         btrfs_print_objectid(key->max_objectid);
 436                 }
 437
 438                 print_key_value(tcp, key, min_offset);
 439                 print_key_value(tcp, key, max_offset);
 440                 print_key_value(tcp, key, min_transid);
 441                 print_key_value(tcp, key, max_transid);
 442
 443                 tprints(", min_type=");
 444                 btrfs_print_key_type(key->min_type);
 445                 tprints(", max_type=");
 446                 btrfs_print_key_type(key->max_type);
 447                 tprintf(", nr_items=%u}", key->nr_items);
 448                 if (print_size)
 449                         tprintf(", buf_size=%" PRIu64, buf_size);
 450                 tprints("}");
 451         } else {
 452                 tprintf("{key={nr_items=%u}", key->nr_items);
 453                 if (print_size)
 454                         tprintf(", buf_size=%" PRIu64, buf_size);
 455                 tprints(", buf=");
 456                 if (abbrev(tcp))
 457                         tprints("...");
 458                 else {
 459                         uint64_t i;
 460                         uint64_t off = 0;
 461                         tprints("[");
 462                         for (i = 0; i < key->nr_items; i++) {
 463                                 struct btrfs_ioctl_search_header sh;
 464                                 uint64_t addr = buf_addr + off;
 465                                 if (i)
 466                                         tprints(", ");
 467                                 if (i > max_strlen ||
 468                                     umove(tcp, addr, &sh)) {
 469                                         tprints("...");
 470                                         break;
 471                                 }
 472                                 tprintf("{transid=%" PRI__u64 ", objectid=",
 473                                         sh.transid);
 474                                 btrfs_print_objectid(sh.objectid);
 475                                 tprintf(", offset=%" PRI__u64 ", type=", sh.offset);
 476                                 btrfs_print_key_type(sh.type);
 477                                 tprintf(", len=%u}", sh.len);
 478                                 off += sizeof(sh) + sh.len;
 479
 480                         }
 481                         tprints("]");
 482                 }
 483                 tprints("}");
 484         }
 485 }
 486
 487 static bool
 488 print_objectid_callback(struct tcb *tcp, void *elem_buf,
 489                         size_t elem_size, void *data)
 490 {
 491         btrfs_print_objectid(* (uint64_t *) elem_buf);
 492
 493         return true;
 494 }
 495
 496 static bool
 497 print_btrfs_ioctl_space_info(struct tcb *tcp, void *elem_buf,
 498                              size_t elem_size, void *data)
 499 {
 500         const struct btrfs_ioctl_space_info *info = elem_buf;
 501
 502         tprints("{flags=");
 503         printflags64(btrfs_space_info_flags, info->flags,
 504                      "BTRFS_SPACE_INFO_???");
 505         tprintf(", total_bytes=%" PRI__u64 ", used_bytes=%" PRI__u64 "}",
 506                 info->total_bytes, info->used_bytes);
 507
 508         return true;
 509 }
 510
 511 MPERS_PRINTER_DECL(int, btrfs_ioctl,
 512                    struct tcb *tcp, const unsigned int code, const long arg)
 513 {
 514         switch (code) {
 515         /* Take no arguments; command only. */
 516         case BTRFS_IOC_TRANS_START:
 517         case BTRFS_IOC_TRANS_END:
 518         case BTRFS_IOC_SYNC:
 519         case BTRFS_IOC_SCRUB_CANCEL:
 520         case BTRFS_IOC_QUOTA_RESCAN_WAIT:
 521         /*
 522          * The codes for these ioctls are based on each accepting a
 523          * vol_args but none of them actually consume an argument.
 524          */
 525         case BTRFS_IOC_DEFRAG:
 526         case BTRFS_IOC_BALANCE:
 527                 break;
 528
 529         /* takes a signed int */
 530         case BTRFS_IOC_BALANCE_CTL:
 531                 tprints(", ");
 532                 printxval(btrfs_balance_ctl_cmds, arg, "BTRFS_BALANCE_CTL_???");
 533                 break;
 534
 535         /* returns a 64 */
 536         case BTRFS_IOC_START_SYNC: /* R */
 537                 if (entering(tcp))
 538                         return 0;
 539         /* fall through */
 540         /* takes a u64 */
 541         case BTRFS_IOC_DEFAULT_SUBVOL: /* W */
 542         case BTRFS_IOC_WAIT_SYNC: /* W */
 543                 tprints(", ");
 544                 printnum_int64(tcp, arg, "%" PRIu64);
 545                 break;
 546
 547         /* u64 but describe a flags bitfield; we can make that symbolic */
 548         case BTRFS_IOC_SUBVOL_GETFLAGS: { /* R */
 549                 uint64_t flags;
 550
 551                 if (entering(tcp))
 552                         return 0;
 553
 554                 tprints(", ");
 555
 556                 if (umove_or_printaddr(tcp, arg, &flags))
 557                         break;
 558
 559                 printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???");
 560                 break;
 561         }
 562
 563         case BTRFS_IOC_SUBVOL_SETFLAGS: { /* W */
 564                 uint64_t flags;
 565
 566                 tprints(", ");
 567
 568                 if (umove_or_printaddr(tcp, arg, &flags))
 569                         break;
 570
 571                 printflags64(btrfs_snap_flags_v2, flags, "BTRFS_SUBVOL_???");
 572                 break;
 573         }
 574
 575         /* More complex types */
 576         case BTRFS_IOC_BALANCE_V2: /* RW */
 577                 if (entering(tcp)) {
 578                         tprints(", ");
 579                         btrfs_print_balance(tcp, arg, false);
 580                         return 0;
 581                 }
 582
 583                 if (syserror(tcp))
 584                         break;
 585
 586                 tprints(" => ");
 587                 btrfs_print_balance(tcp, arg, true);
 588                 break;
 589         case BTRFS_IOC_BALANCE_PROGRESS: /* R */
 590                 if (entering(tcp))
 591                         return 0;
 592
 593                 tprints(", ");
 594                 btrfs_print_balance(tcp, arg, true);
 595                 break;
 596
 597         case BTRFS_IOC_DEFRAG_RANGE: { /* W */
 598                 struct btrfs_ioctl_defrag_range_args args;
 599
 600                 tprints(", ");
 601
 602                 if (umove_or_printaddr(tcp, arg, &args))
 603                         break;
 604
 605                 tprintf("{start=%" PRIu64 ", len=", (uint64_t)args.start);
 606
 607                 tprintf("%" PRIu64, (uint64_t) args.len);
 608                 if (args.len == UINT64_MAX)
 609                         tprints(" /* UINT64_MAX */");
 610
 611                 tprints(", flags=");
 612                 printflags64(btrfs_defrag_flags, args.flags,
 613                              "BTRFS_DEFRAG_RANGE_???");
 614                 tprintf(", extent_thresh=%u, compress_type=",
 615                         args.extent_thresh);
 616                 printxval(btrfs_compress_types, args.compress_type,
 617                           "BTRFS_COMPRESS_???");
 618                 tprints("}");
 619                 break;
 620         }
 621
 622         case BTRFS_IOC_DEV_INFO: { /* RW */
 623                 struct btrfs_ioctl_dev_info_args args;
 624                 char uuid[UUID_STRING_SIZE+1];
 625                 int valid;
 626
 627                 if (entering(tcp))
 628                         tprints(", ");
 629                 else if (syserror(tcp))
 630                         break;
 631                 else
 632                         tprints(" => ");
 633                 if (umove_or_printaddr(tcp, arg, &args))
 634                         break;
 635                 tprints("{");
 636
 637                 valid = btrfs_unparse_uuid(args.uuid, uuid);
 638                 if (entering(tcp)) {
 639                         tprintf("devid=%" PRI__u64, args.devid);
 640                         if (valid)
 641                                 tprintf(", uuid=%s", uuid);
 642                         tprints("}");
 643                         return 0;
 644                 }
 645                 if (valid)
 646                         tprintf("uuid=%s, ", uuid);
 647                 tprintf("bytes_used=%" PRI__u64
 648                         ", total_bytes=%" PRI__u64 ", path=",
 649                         args.bytes_used, args.total_bytes);
 650                 print_quoted_string((const char *)args.path, sizeof(args.path),
 651                                     QUOTE_0_TERMINATED);
 652                 tprints("}");
 653                 break;
 654         }
 655
 656         case BTRFS_IOC_DEV_REPLACE: { /* RW */
 657                 struct_btrfs_ioctl_dev_replace_args args;
 658
 659                 if (entering(tcp))
 660                         tprints(", ");
 661                 else if (syserror(tcp))
 662                         break;
 663                 else
 664                         tprints(" => ");
 665
 666                 if (umove_or_printaddr(tcp, arg, &args))
 667                         break;
 668
 669                 if (entering(tcp)) {
 670                         tprints("{cmd=");
 671                         printxval64(btrfs_dev_replace_cmds, args.cmd,
 672                                     "BTRFS_IOCTL_DEV_REPLACE_CMD_???");
 673                         if (args.cmd == BTRFS_IOCTL_DEV_REPLACE_CMD_START) {
 674                                 const char *str;
 675                                 tprintf(", start={srcdevid=%" PRIu64
 676                                    ", cont_reading_from_srcdev_mode=%" PRIu64
 677                                    ", srcdev_name=",
 678                                    (uint64_t) args.start.srcdevid,
 679                                    (uint64_t) args.start.cont_reading_from_srcdev_mode);
 680
 681                                 str = (const char*) args.start.srcdev_name;
 682                                 print_quoted_string(str,
 683                                                 sizeof(args.start.srcdev_name),
 684                                                 QUOTE_0_TERMINATED);
 685                                 tprints(", tgtdev_name=");
 686                                 str = (const char*) args.start.tgtdev_name;
 687                                 print_quoted_string(str,
 688                                                 sizeof(args.start.tgtdev_name),
 689                                                 QUOTE_0_TERMINATED);
 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                         char buf[sizeof("HH:MM:SS") + 1];
 702                         time_t time;
 703                         tprints(", ");
 704                         printxval64(btrfs_dev_replace_state,
 705                                    args.status.replace_state,
 706                                    "BTRFS_IOCTL_DEV_REPLACE_STATE_???");
 707                         tprintf(", progress_1000=%" PRIu64 " /* ",
 708                                 (uint64_t) args.status.progress_1000);
 709                         if (args.status.progress_1000 <= 1000)
 710                                 tprintf("%" PRIu64 ".%.2" PRIu64 "%%",
 711                                         (uint64_t) args.status.progress_1000 / 10,
 712                                         (uint64_t) args.status.progress_1000 % 10);
 713                         else
 714                                 tprints("???");
 715                         tprints(" */ ,");
 716
 717                         time = args.status.time_started;
 718                         strftime(buf, sizeof(buf), "%T",
 719                                  localtime(&time));
 720                         tprintf("time_started=%" PRIu64" /* %s */, ",
 721                                 (uint64_t) args.status.time_started, buf);
 722
 723                         time = args.status.time_stopped;
 724                         strftime(buf, sizeof(buf), "%T",
 725                                  localtime(&time));
 726                         tprintf("time_stopped=%" PRIu64" /* %s */, ",
 727                                 (uint64_t) args.status.time_stopped, buf);
 728
 729                         tprintf("num_write_errors=%" PRIu64
 730                                 ", num_uncorrectable_read_errors=%" PRIu64,
 731                                 (uint64_t) args.status.num_write_errors,
 732                                 (uint64_t) args.status.num_uncorrectable_read_errors);
 733                 }
 734                 tprints("}");
 735                 break;
 736         }
 737
 738         case BTRFS_IOC_GET_FEATURES: { /* R */
 739                 struct btrfs_ioctl_feature_flags flags;
 740
 741                 if (entering(tcp))
 742                         return 0;
 743
 744                 tprints(", ");
 745                 if (umove_or_printaddr(tcp, arg, &flags))
 746                         break;
 747
 748                 btrfs_print_features(&flags);
 749                 break;
 750         }
 751
 752         case BTRFS_IOC_SET_FEATURES: { /* W */
 753                 struct btrfs_ioctl_feature_flags flarg[2];
 754
 755                 tprints(", ");
 756
 757                 if (umove_or_printaddr(tcp, arg, &flarg))
 758                         break;
 759
 760                 tprints("[");
 761                 btrfs_print_features(&flarg[0]);
 762                 tprints(", ");
 763                 btrfs_print_features(&flarg[1]);
 764                 tprints("]");
 765                 break;
 766         }
 767
 768         case BTRFS_IOC_GET_SUPPORTED_FEATURES: { /* R */
 769                 struct btrfs_ioctl_feature_flags flarg[3];
 770
 771                 if (entering(tcp))
 772                         return 0;
 773
 774                 tprints(", ");
 775                 if (umove_or_printaddr(tcp, arg, &flarg))
 776                         break;
 777
 778                 tprints("[ /* supported */ ");
 779                 btrfs_print_features(&flarg[0]);
 780
 781                 tprints(", /* safe to set */ ");
 782                 btrfs_print_features(&flarg[1]);
 783
 784                 tprints(", /* safe to clear */ ");
 785                 btrfs_print_features(&flarg[2]);
 786                 tprints("]");
 787
 788                 break;
 789         }
 790
 791         case BTRFS_IOC_FS_INFO: { /* R */
 792                 struct btrfs_ioctl_fs_info_args args;
 793                 char uuid[UUID_STRING_SIZE+1];
 794                 uint32_t nodesize, sectorsize, clone_alignment;
 795 #ifndef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE
 796                 __u32 *reserved32;
 797 #endif
 798
 799                 if (entering(tcp))
 800                         return 0;
 801
 802                 tprints(", ");
 803                 if (umove_or_printaddr(tcp, arg, &args))
 804                         break;
 805
 806 #ifdef HAVE_STRUCT_BTRFS_IOCTL_FS_INFO_ARGS_NODESIZE
 807                 nodesize = args.nodesize,
 808                 sectorsize = args.sectorsize,
 809                 clone_alignment = args.clone_alignment;
 810 #else
 811                 reserved32 = (__u32 *)args.reserved;
 812                 nodesize = reserved32[0];
 813                 sectorsize = reserved32[1];
 814                 clone_alignment = reserved32[2];
 815 #endif
 816                 btrfs_unparse_uuid(args.fsid, uuid);
 817
 818                 tprints("{");
 819                 tprintf("max_id=%" PRI__u64 ", num_devices=%" PRI__u64
 820                         ", fsid=%s, nodesize=%u, sectorsize=%u"
 821                         ", clone_alignment=%u",
 822                         args.max_id, args.num_devices, uuid,
 823                         nodesize, sectorsize, clone_alignment);
 824                 tprints("}");
 825                 break;
 826         }
 827
 828         case BTRFS_IOC_GET_DEV_STATS: { /* RW */
 829                 struct btrfs_ioctl_get_dev_stats args;
 830                 uint64_t i;
 831
 832                 if (entering(tcp))
 833                         tprints(", ");
 834                 else if (syserror(tcp))
 835                         break;
 836                 else
 837                         tprints(" => ");
 838                 if (umove_or_printaddr(tcp, arg, &args))
 839                         break;
 840
 841                 tprints("{");
 842
 843                 if (entering(tcp))
 844                         tprintf("devid=%" PRI__u64 ", ", args.devid);
 845
 846                 tprintf("nr_items=%" PRI__u64 ", flags=", args.nr_items);
 847                 printflags64(btrfs_dev_stats_flags, args.flags,
 848                              "BTRFS_DEV_STATS_???");
 849
 850                 if (entering(tcp)) {
 851                         tprints("}");
 852                         return 0;
 853                 }
 854
 855                 /*
 856                  * The structure has a 1k limit; Let's make sure we don't
 857                  * go off into the middle of nowhere with a bad nr_items
 858                  * value.
 859                  */
 860                 tprints(", [");
 861                 for (i = 0; i < args.nr_items; i++) {
 862                         if (i)
 863                                 tprints(", ");
 864                         if (i >= ARRAY_SIZE(args.values)) {
 865                                 tprints("...");
 866                                 break;
 867                         }
 868                         const char *name = xlookup(btrfs_dev_stats_values, i);
 869                         if (name)
 870                                 tprintf("/* %s */ ", name);
 871                         tprintf("%" PRI__u64, args.values[i]);
 872                 }
 873                 tprints("]}");
 874                 break;
 875         }
 876
 877         case BTRFS_IOC_INO_LOOKUP: { /* RW */
 878                 struct btrfs_ioctl_ino_lookup_args args;
 879
 880                 if (entering(tcp))
 881                         tprints(", ");
 882                 else if (syserror(tcp))
 883                         break;
 884                 else
 885                         tprints(" => ");
 886
 887                 if (umove_or_printaddr(tcp, arg, &args))
 888                         break;
 889
 890                 if (entering(tcp)) {
 891                         /* Use subvolume id of the containing root */
 892                         if (args.treeid == 0)
 893                                 /* abuse of auxstr to retain state */
 894                                 tcp->auxstr = (void *)1;
 895                         else
 896                                 tcp->auxstr = NULL;
 897
 898                         tprints("{treeid=");
 899                         btrfs_print_objectid(args.treeid);
 900                         tprints(", objectid=");
 901                         btrfs_print_objectid(args.objectid);
 902                         tprints("}");
 903                         return 0;
 904                 }
 905
 906                 tprints("{");
 907                 if (tcp->auxstr) {
 908                         tcp->auxstr = NULL;
 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, (unsigned long) 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=%" PRI__u64 ", qgroup_inherit=",
1321                                         args.size);
1322
1323                                 btrfs_print_qgroup_inherit(tcp,
1324                                         (unsigned long)args.qgroup_inherit);
1325                         }
1326                         tprintf(", name=");
1327                         print_quoted_string(args.name, sizeof(args.name),
1328                                             QUOTE_0_TERMINATED);
1329                         tprints("}");
1330                         return 0;
1331                 }
1332                 tprintf("{transid=%" PRI__u64 "}", 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 */