linux/fs/btrfs/super.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (C) 2007 Oracle.  All rights reserved.
   4 */
   5
   6#include <linux/blkdev.h>
   7#include <linux/module.h>
   8#include <linux/fs.h>
   9#include <linux/pagemap.h>
  10#include <linux/highmem.h>
  11#include <linux/time.h>
  12#include <linux/init.h>
  13#include <linux/seq_file.h>
  14#include <linux/string.h>
  15#include <linux/backing-dev.h>
  16#include <linux/mount.h>
  17#include <linux/writeback.h>
  18#include <linux/statfs.h>
  19#include <linux/compat.h>
  20#include <linux/parser.h>
  21#include <linux/ctype.h>
  22#include <linux/namei.h>
  23#include <linux/miscdevice.h>
  24#include <linux/magic.h>
  25#include <linux/slab.h>
  26#include <linux/cleancache.h>
  27#include <linux/ratelimit.h>
  28#include <linux/crc32c.h>
  29#include <linux/btrfs.h>
  30#include "delayed-inode.h"
  31#include "ctree.h"
  32#include "disk-io.h"
  33#include "transaction.h"
  34#include "btrfs_inode.h"
  35#include "print-tree.h"
  36#include "props.h"
  37#include "xattr.h"
  38#include "volumes.h"
  39#include "export.h"
  40#include "compression.h"
  41#include "rcu-string.h"
  42#include "dev-replace.h"
  43#include "free-space-cache.h"
  44#include "backref.h"
  45#include "space-info.h"
  46#include "sysfs.h"
  47#include "zoned.h"
  48#include "tests/btrfs-tests.h"
  49#include "block-group.h"
  50#include "discard.h"
  51#include "qgroup.h"
  52#define CREATE_TRACE_POINTS
  53#include <trace/events/btrfs.h>
  54
  55static const struct super_operations btrfs_super_ops;
  56
  57/*
  58 * Types for mounting the default subvolume and a subvolume explicitly
  59 * requested by subvol=/path. That way the callchain is straightforward and we
  60 * don't have to play tricks with the mount options and recursive calls to
  61 * btrfs_mount.
  62 *
  63 * The new btrfs_root_fs_type also servers as a tag for the bdev_holder.
  64 */
  65static struct file_system_type btrfs_fs_type;
  66static struct file_system_type btrfs_root_fs_type;
  67
  68static int btrfs_remount(struct super_block *sb, int *flags, char *data);
  69
  70/*
  71 * Generally the error codes correspond to their respective errors, but there
  72 * are a few special cases.
  73 *
  74 * EUCLEAN: Any sort of corruption that we encounter.  The tree-checker for
  75 *          instance will return EUCLEAN if any of the blocks are corrupted in
  76 *          a way that is problematic.  We want to reserve EUCLEAN for these
  77 *          sort of corruptions.
  78 *
  79 * EROFS: If we check BTRFS_FS_STATE_ERROR and fail out with a return error, we
  80 *        need to use EROFS for this case.  We will have no idea of the
  81 *        original failure, that will have been reported at the time we tripped
  82 *        over the error.  Each subsequent error that doesn't have any context
  83 *        of the original error should use EROFS when handling BTRFS_FS_STATE_ERROR.
  84 */
  85const char * __attribute_const__ btrfs_decode_error(int errno)
  86{
  87        char *errstr = "unknown";
  88
  89        switch (errno) {
  90        case -ENOENT:           /* -2 */
  91                errstr = "No such entry";
  92                break;
  93        case -EIO:              /* -5 */
  94                errstr = "IO failure";
  95                break;
  96        case -ENOMEM:           /* -12*/
  97                errstr = "Out of memory";
  98                break;
  99        case -EEXIST:           /* -17 */
 100                errstr = "Object already exists";
 101                break;
 102        case -ENOSPC:           /* -28 */
 103                errstr = "No space left";
 104                break;
 105        case -EROFS:            /* -30 */
 106                errstr = "Readonly filesystem";
 107                break;
 108        case -EOPNOTSUPP:       /* -95 */
 109                errstr = "Operation not supported";
 110                break;
 111        case -EUCLEAN:          /* -117 */
 112                errstr = "Filesystem corrupted";
 113                break;
 114        case -EDQUOT:           /* -122 */
 115                errstr = "Quota exceeded";
 116                break;
 117        }
 118
 119        return errstr;
 120}
 121
 122/*
 123 * __btrfs_handle_fs_error decodes expected errors from the caller and
 124 * invokes the appropriate error response.
 125 */
 126__cold
 127void __btrfs_handle_fs_error(struct btrfs_fs_info *fs_info, const char *function,
 128                       unsigned int line, int errno, const char *fmt, ...)
 129{
 130        struct super_block *sb = fs_info->sb;
 131#ifdef CONFIG_PRINTK
 132        const char *errstr;
 133#endif
 134
 135        /*
 136         * Special case: if the error is EROFS, and we're already
 137         * under SB_RDONLY, then it is safe here.
 138         */
 139        if (errno == -EROFS && sb_rdonly(sb))
 140                return;
 141
 142#ifdef CONFIG_PRINTK
 143        errstr = btrfs_decode_error(errno);
 144        if (fmt) {
 145                struct va_format vaf;
 146                va_list args;
 147
 148                va_start(args, fmt);
 149                vaf.fmt = fmt;
 150                vaf.va = &args;
 151
 152                pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)\n",
 153                        sb->s_id, function, line, errno, errstr, &vaf);
 154                va_end(args);
 155        } else {
 156                pr_crit("BTRFS: error (device %s) in %s:%d: errno=%d %s\n",
 157                        sb->s_id, function, line, errno, errstr);
 158        }
 159#endif
 160
 161        /*
 162         * Today we only save the error info to memory.  Long term we'll
 163         * also send it down to the disk
 164         */
 165        set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
 166
 167        /* Don't go through full error handling during mount */
 168        if (!(sb->s_flags & SB_BORN))
 169                return;
 170
 171        if (sb_rdonly(sb))
 172                return;
 173
 174        btrfs_discard_stop(fs_info);
 175
 176        /* btrfs handle error by forcing the filesystem readonly */
 177        btrfs_set_sb_rdonly(sb);
 178        btrfs_info(fs_info, "forced readonly");
 179        /*
 180         * Note that a running device replace operation is not canceled here
 181         * although there is no way to update the progress. It would add the
 182         * risk of a deadlock, therefore the canceling is omitted. The only
 183         * penalty is that some I/O remains active until the procedure
 184         * completes. The next time when the filesystem is mounted writable
 185         * again, the device replace operation continues.
 186         */
 187}
 188
 189#ifdef CONFIG_PRINTK
 190static const char * const logtypes[] = {
 191        "emergency",
 192        "alert",
 193        "critical",
 194        "error",
 195        "warning",
 196        "notice",
 197        "info",
 198        "debug",
 199};
 200
 201
 202/*
 203 * Use one ratelimit state per log level so that a flood of less important
 204 * messages doesn't cause more important ones to be dropped.
 205 */
 206static struct ratelimit_state printk_limits[] = {
 207        RATELIMIT_STATE_INIT(printk_limits[0], DEFAULT_RATELIMIT_INTERVAL, 100),
 208        RATELIMIT_STATE_INIT(printk_limits[1], DEFAULT_RATELIMIT_INTERVAL, 100),
 209        RATELIMIT_STATE_INIT(printk_limits[2], DEFAULT_RATELIMIT_INTERVAL, 100),
 210        RATELIMIT_STATE_INIT(printk_limits[3], DEFAULT_RATELIMIT_INTERVAL, 100),
 211        RATELIMIT_STATE_INIT(printk_limits[4], DEFAULT_RATELIMIT_INTERVAL, 100),
 212        RATELIMIT_STATE_INIT(printk_limits[5], DEFAULT_RATELIMIT_INTERVAL, 100),
 213        RATELIMIT_STATE_INIT(printk_limits[6], DEFAULT_RATELIMIT_INTERVAL, 100),
 214        RATELIMIT_STATE_INIT(printk_limits[7], DEFAULT_RATELIMIT_INTERVAL, 100),
 215};
 216
 217void __cold btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
 218{
 219        char lvl[PRINTK_MAX_SINGLE_HEADER_LEN + 1] = "\0";
 220        struct va_format vaf;
 221        va_list args;
 222        int kern_level;
 223        const char *type = logtypes[4];
 224        struct ratelimit_state *ratelimit = &printk_limits[4];
 225
 226        va_start(args, fmt);
 227
 228        while ((kern_level = printk_get_level(fmt)) != 0) {
 229                size_t size = printk_skip_level(fmt) - fmt;
 230
 231                if (kern_level >= '0' && kern_level <= '7') {
 232                        memcpy(lvl, fmt,  size);
 233                        lvl[size] = '\0';
 234                        type = logtypes[kern_level - '0'];
 235                        ratelimit = &printk_limits[kern_level - '0'];
 236                }
 237                fmt += size;
 238        }
 239
 240        vaf.fmt = fmt;
 241        vaf.va = &args;
 242
 243        if (__ratelimit(ratelimit)) {
 244                if (fs_info)
 245                        printk("%sBTRFS %s (device %s): %pV\n", lvl, type,
 246                                fs_info->sb->s_id, &vaf);
 247                else
 248                        printk("%sBTRFS %s: %pV\n", lvl, type, &vaf);
 249        }
 250
 251        va_end(args);
 252}
 253#endif
 254
 255#if BITS_PER_LONG == 32
 256void __cold btrfs_warn_32bit_limit(struct btrfs_fs_info *fs_info)
 257{
 258        if (!test_and_set_bit(BTRFS_FS_32BIT_WARN, &fs_info->flags)) {
 259                btrfs_warn(fs_info, "reaching 32bit limit for logical addresses");
 260                btrfs_warn(fs_info,
 261"due to page cache limit on 32bit systems, btrfs can't access metadata at or beyond %lluT",
 262                           BTRFS_32BIT_MAX_FILE_SIZE >> 40);
 263                btrfs_warn(fs_info,
 264                           "please consider upgrading to 64bit kernel/hardware");
 265        }
 266}
 267
 268void __cold btrfs_err_32bit_limit(struct btrfs_fs_info *fs_info)
 269{
 270        if (!test_and_set_bit(BTRFS_FS_32BIT_ERROR, &fs_info->flags)) {
 271                btrfs_err(fs_info, "reached 32bit limit for logical addresses");
 272                btrfs_err(fs_info,
 273"due to page cache limit on 32bit systems, metadata beyond %lluT can't be accessed",
 274                          BTRFS_32BIT_MAX_FILE_SIZE >> 40);
 275                btrfs_err(fs_info,
 276                           "please consider upgrading to 64bit kernel/hardware");
 277        }
 278}
 279#endif
 280
 281/*
 282 * We only mark the transaction aborted and then set the file system read-only.
 283 * This will prevent new transactions from starting or trying to join this
 284 * one.
 285 *
 286 * This means that error recovery at the call site is limited to freeing
 287 * any local memory allocations and passing the error code up without
 288 * further cleanup. The transaction should complete as it normally would
 289 * in the call path but will return -EIO.
 290 *
 291 * We'll complete the cleanup in btrfs_end_transaction and
 292 * btrfs_commit_transaction.
 293 */
 294__cold
 295void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
 296                               const char *function,
 297                               unsigned int line, int errno)
 298{
 299        struct btrfs_fs_info *fs_info = trans->fs_info;
 300
 301        WRITE_ONCE(trans->aborted, errno);
 302        WRITE_ONCE(trans->transaction->aborted, errno);
 303        /* Wake up anybody who may be waiting on this transaction */
 304        wake_up(&fs_info->transaction_wait);
 305        wake_up(&fs_info->transaction_blocked_wait);
 306        __btrfs_handle_fs_error(fs_info, function, line, errno, NULL);
 307}
 308/*
 309 * __btrfs_panic decodes unexpected, fatal errors from the caller,
 310 * issues an alert, and either panics or BUGs, depending on mount options.
 311 */
 312__cold
 313void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
 314                   unsigned int line, int errno, const char *fmt, ...)
 315{
 316        char *s_id = "<unknown>";
 317        const char *errstr;
 318        struct va_format vaf = { .fmt = fmt };
 319        va_list args;
 320
 321        if (fs_info)
 322                s_id = fs_info->sb->s_id;
 323
 324        va_start(args, fmt);
 325        vaf.va = &args;
 326
 327        errstr = btrfs_decode_error(errno);
 328        if (fs_info && (btrfs_test_opt(fs_info, PANIC_ON_FATAL_ERROR)))
 329                panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
 330                        s_id, function, line, &vaf, errno, errstr);
 331
 332        btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
 333                   function, line, &vaf, errno, errstr);
 334        va_end(args);
 335        /* Caller calls BUG() */
 336}
 337
 338static void btrfs_put_super(struct super_block *sb)
 339{
 340        close_ctree(btrfs_sb(sb));
 341}
 342
 343enum {
 344        Opt_acl, Opt_noacl,
 345        Opt_clear_cache,
 346        Opt_commit_interval,
 347        Opt_compress,
 348        Opt_compress_force,
 349        Opt_compress_force_type,
 350        Opt_compress_type,
 351        Opt_degraded,
 352        Opt_device,
 353        Opt_fatal_errors,
 354        Opt_flushoncommit, Opt_noflushoncommit,
 355        Opt_max_inline,
 356        Opt_barrier, Opt_nobarrier,
 357        Opt_datacow, Opt_nodatacow,
 358        Opt_datasum, Opt_nodatasum,
 359        Opt_defrag, Opt_nodefrag,
 360        Opt_discard, Opt_nodiscard,
 361        Opt_discard_mode,
 362        Opt_norecovery,
 363        Opt_ratio,
 364        Opt_rescan_uuid_tree,
 365        Opt_skip_balance,
 366        Opt_space_cache, Opt_no_space_cache,
 367        Opt_space_cache_version,
 368        Opt_ssd, Opt_nossd,
 369        Opt_ssd_spread, Opt_nossd_spread,
 370        Opt_subvol,
 371        Opt_subvol_empty,
 372        Opt_subvolid,
 373        Opt_thread_pool,
 374        Opt_treelog, Opt_notreelog,
 375        Opt_user_subvol_rm_allowed,
 376
 377        /* Rescue options */
 378        Opt_rescue,
 379        Opt_usebackuproot,
 380        Opt_nologreplay,
 381        Opt_ignorebadroots,
 382        Opt_ignoredatacsums,
 383        Opt_rescue_all,
 384
 385        /* Deprecated options */
 386        Opt_recovery,
 387        Opt_inode_cache, Opt_noinode_cache,
 388
 389        /* Debugging options */
 390        Opt_check_integrity,
 391        Opt_check_integrity_including_extent_data,
 392        Opt_check_integrity_print_mask,
 393        Opt_enospc_debug, Opt_noenospc_debug,
 394#ifdef CONFIG_BTRFS_DEBUG
 395        Opt_fragment_data, Opt_fragment_metadata, Opt_fragment_all,
 396#endif
 397#ifdef CONFIG_BTRFS_FS_REF_VERIFY
 398        Opt_ref_verify,
 399#endif
 400        Opt_err,
 401};
 402
 403static const match_table_t tokens = {
 404        {Opt_acl, "acl"},
 405        {Opt_noacl, "noacl"},
 406        {Opt_clear_cache, "clear_cache"},
 407        {Opt_commit_interval, "commit=%u"},
 408        {Opt_compress, "compress"},
 409        {Opt_compress_type, "compress=%s"},
 410        {Opt_compress_force, "compress-force"},
 411        {Opt_compress_force_type, "compress-force=%s"},
 412        {Opt_degraded, "degraded"},
 413        {Opt_device, "device=%s"},
 414        {Opt_fatal_errors, "fatal_errors=%s"},
 415        {Opt_flushoncommit, "flushoncommit"},
 416        {Opt_noflushoncommit, "noflushoncommit"},
 417        {Opt_inode_cache, "inode_cache"},
 418        {Opt_noinode_cache, "noinode_cache"},
 419        {Opt_max_inline, "max_inline=%s"},
 420        {Opt_barrier, "barrier"},
 421        {Opt_nobarrier, "nobarrier"},
 422        {Opt_datacow, "datacow"},
 423        {Opt_nodatacow, "nodatacow"},
 424        {Opt_datasum, "datasum"},
 425        {Opt_nodatasum, "nodatasum"},
 426        {Opt_defrag, "autodefrag"},
 427        {Opt_nodefrag, "noautodefrag"},
 428        {Opt_discard, "discard"},
 429        {Opt_discard_mode, "discard=%s"},
 430        {Opt_nodiscard, "nodiscard"},
 431        {Opt_norecovery, "norecovery"},
 432        {Opt_ratio, "metadata_ratio=%u"},
 433        {Opt_rescan_uuid_tree, "rescan_uuid_tree"},
 434        {Opt_skip_balance, "skip_balance"},
 435        {Opt_space_cache, "space_cache"},
 436        {Opt_no_space_cache, "nospace_cache"},
 437        {Opt_space_cache_version, "space_cache=%s"},
 438        {Opt_ssd, "ssd"},
 439        {Opt_nossd, "nossd"},
 440        {Opt_ssd_spread, "ssd_spread"},
 441        {Opt_nossd_spread, "nossd_spread"},
 442        {Opt_subvol, "subvol=%s"},
 443        {Opt_subvol_empty, "subvol="},
 444        {Opt_subvolid, "subvolid=%s"},
 445        {Opt_thread_pool, "thread_pool=%u"},
 446        {Opt_treelog, "treelog"},
 447        {Opt_notreelog, "notreelog"},
 448        {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
 449
 450        /* Rescue options */
 451        {Opt_rescue, "rescue=%s"},
 452        /* Deprecated, with alias rescue=nologreplay */
 453        {Opt_nologreplay, "nologreplay"},
 454        /* Deprecated, with alias rescue=usebackuproot */
 455        {Opt_usebackuproot, "usebackuproot"},
 456
 457        /* Deprecated options */
 458        {Opt_recovery, "recovery"},
 459
 460        /* Debugging options */
 461        {Opt_check_integrity, "check_int"},
 462        {Opt_check_integrity_including_extent_data, "check_int_data"},
 463        {Opt_check_integrity_print_mask, "check_int_print_mask=%u"},
 464        {Opt_enospc_debug, "enospc_debug"},
 465        {Opt_noenospc_debug, "noenospc_debug"},
 466#ifdef CONFIG_BTRFS_DEBUG
 467        {Opt_fragment_data, "fragment=data"},
 468        {Opt_fragment_metadata, "fragment=metadata"},
 469        {Opt_fragment_all, "fragment=all"},
 470#endif
 471#ifdef CONFIG_BTRFS_FS_REF_VERIFY
 472        {Opt_ref_verify, "ref_verify"},
 473#endif
 474        {Opt_err, NULL},
 475};
 476
 477static const match_table_t rescue_tokens = {
 478        {Opt_usebackuproot, "usebackuproot"},
 479        {Opt_nologreplay, "nologreplay"},
 480        {Opt_ignorebadroots, "ignorebadroots"},
 481        {Opt_ignorebadroots, "ibadroots"},
 482        {Opt_ignoredatacsums, "ignoredatacsums"},
 483        {Opt_ignoredatacsums, "idatacsums"},
 484        {Opt_rescue_all, "all"},
 485        {Opt_err, NULL},
 486};
 487
 488static bool check_ro_option(struct btrfs_fs_info *fs_info, unsigned long opt,
 489                            const char *opt_name)
 490{
 491        if (fs_info->mount_opt & opt) {
 492                btrfs_err(fs_info, "%s must be used with ro mount option",
 493                          opt_name);
 494                return true;
 495        }
 496        return false;
 497}
 498
 499static int parse_rescue_options(struct btrfs_fs_info *info, const char *options)
 500{
 501        char *opts;
 502        char *orig;
 503        char *p;
 504        substring_t args[MAX_OPT_ARGS];
 505        int ret = 0;
 506
 507        opts = kstrdup(options, GFP_KERNEL);
 508        if (!opts)
 509                return -ENOMEM;
 510        orig = opts;
 511
 512        while ((p = strsep(&opts, ":")) != NULL) {
 513                int token;
 514
 515                if (!*p)
 516                        continue;
 517                token = match_token(p, rescue_tokens, args);
 518                switch (token){
 519                case Opt_usebackuproot:
 520                        btrfs_info(info,
 521                                   "trying to use backup root at mount time");
 522                        btrfs_set_opt(info->mount_opt, USEBACKUPROOT);
 523                        break;
 524                case Opt_nologreplay:
 525                        btrfs_set_and_info(info, NOLOGREPLAY,
 526                                           "disabling log replay at mount time");
 527                        break;
 528                case Opt_ignorebadroots:
 529                        btrfs_set_and_info(info, IGNOREBADROOTS,
 530                                           "ignoring bad roots");
 531                        break;
 532                case Opt_ignoredatacsums:
 533                        btrfs_set_and_info(info, IGNOREDATACSUMS,
 534                                           "ignoring data csums");
 535                        break;
 536                case Opt_rescue_all:
 537                        btrfs_info(info, "enabling all of the rescue options");
 538                        btrfs_set_and_info(info, IGNOREDATACSUMS,
 539                                           "ignoring data csums");
 540                        btrfs_set_and_info(info, IGNOREBADROOTS,
 541                                           "ignoring bad roots");
 542                        btrfs_set_and_info(info, NOLOGREPLAY,
 543                                           "disabling log replay at mount time");
 544                        break;
 545                case Opt_err:
 546                        btrfs_info(info, "unrecognized rescue option '%s'", p);
 547                        ret = -EINVAL;
 548                        goto out;
 549                default:
 550                        break;
 551                }
 552
 553        }
 554out:
 555        kfree(orig);
 556        return ret;
 557}
 558
 559/*
 560 * Regular mount options parser.  Everything that is needed only when
 561 * reading in a new superblock is parsed here.
 562 * XXX JDM: This needs to be cleaned up for remount.
 563 */
 564int btrfs_parse_options(struct btrfs_fs_info *info, char *options,
 565                        unsigned long new_flags)
 566{
 567        substring_t args[MAX_OPT_ARGS];
 568        char *p, *num;
 569        int intarg;
 570        int ret = 0;
 571        char *compress_type;
 572        bool compress_force = false;
 573        enum btrfs_compression_type saved_compress_type;
 574        int saved_compress_level;
 575        bool saved_compress_force;
 576        int no_compress = 0;
 577
 578        if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
 579                btrfs_set_opt(info->mount_opt, FREE_SPACE_TREE);
 580        else if (btrfs_free_space_cache_v1_active(info)) {
 581                if (btrfs_is_zoned(info)) {
 582                        btrfs_info(info,
 583                        "zoned: clearing existing space cache");
 584                        btrfs_set_super_cache_generation(info->super_copy, 0);
 585                } else {
 586                        btrfs_set_opt(info->mount_opt, SPACE_CACHE);
 587                }
 588        }
 589
 590        /*
 591         * Even the options are empty, we still need to do extra check
 592         * against new flags
 593         */
 594        if (!options)
 595                goto check;
 596
 597        while ((p = strsep(&options, ",")) != NULL) {
 598                int token;
 599                if (!*p)
 600                        continue;
 601
 602                token = match_token(p, tokens, args);
 603                switch (token) {
 604                case Opt_degraded:
 605                        btrfs_info(info, "allowing degraded mounts");
 606                        btrfs_set_opt(info->mount_opt, DEGRADED);
 607                        break;
 608                case Opt_subvol:
 609                case Opt_subvol_empty:
 610                case Opt_subvolid:
 611                case Opt_device:
 612                        /*
 613                         * These are parsed by btrfs_parse_subvol_options or
 614                         * btrfs_parse_device_options and can be ignored here.
 615                         */
 616                        break;
 617                case Opt_nodatasum:
 618                        btrfs_set_and_info(info, NODATASUM,
 619                                           "setting nodatasum");
 620                        break;
 621                case Opt_datasum:
 622                        if (btrfs_test_opt(info, NODATASUM)) {
 623                                if (btrfs_test_opt(info, NODATACOW))
 624                                        btrfs_info(info,
 625                                                   "setting datasum, datacow enabled");
 626                                else
 627                                        btrfs_info(info, "setting datasum");
 628                        }
 629                        btrfs_clear_opt(info->mount_opt, NODATACOW);
 630                        btrfs_clear_opt(info->mount_opt, NODATASUM);
 631                        break;
 632                case Opt_nodatacow:
 633                        if (!btrfs_test_opt(info, NODATACOW)) {
 634                                if (!btrfs_test_opt(info, COMPRESS) ||
 635                                    !btrfs_test_opt(info, FORCE_COMPRESS)) {
 636                                        btrfs_info(info,
 637                                                   "setting nodatacow, compression disabled");
 638                                } else {
 639                                        btrfs_info(info, "setting nodatacow");
 640                                }
 641                        }
 642                        btrfs_clear_opt(info->mount_opt, COMPRESS);
 643                        btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
 644                        btrfs_set_opt(info->mount_opt, NODATACOW);
 645                        btrfs_set_opt(info->mount_opt, NODATASUM);
 646                        break;
 647                case Opt_datacow:
 648                        btrfs_clear_and_info(info, NODATACOW,
 649                                             "setting datacow");
 650                        break;
 651                case Opt_compress_force:
 652                case Opt_compress_force_type:
 653                        compress_force = true;
 654                        fallthrough;
 655                case Opt_compress:
 656                case Opt_compress_type:
 657                        saved_compress_type = btrfs_test_opt(info,
 658                                                             COMPRESS) ?
 659                                info->compress_type : BTRFS_COMPRESS_NONE;
 660                        saved_compress_force =
 661                                btrfs_test_opt(info, FORCE_COMPRESS);
 662                        saved_compress_level = info->compress_level;
 663                        if (token == Opt_compress ||
 664                            token == Opt_compress_force ||
 665                            strncmp(args[0].from, "zlib", 4) == 0) {
 666                                compress_type = "zlib";
 667
 668                                info->compress_type = BTRFS_COMPRESS_ZLIB;
 669                                info->compress_level = BTRFS_ZLIB_DEFAULT_LEVEL;
 670                                /*
 671                                 * args[0] contains uninitialized data since
 672                                 * for these tokens we don't expect any
 673                                 * parameter.
 674                                 */
 675                                if (token != Opt_compress &&
 676                                    token != Opt_compress_force)
 677                                        info->compress_level =
 678                                          btrfs_compress_str2level(
 679                                                        BTRFS_COMPRESS_ZLIB,
 680                                                        args[0].from + 4);
 681                                btrfs_set_opt(info->mount_opt, COMPRESS);
 682                                btrfs_clear_opt(info->mount_opt, NODATACOW);
 683                                btrfs_clear_opt(info->mount_opt, NODATASUM);
 684                                no_compress = 0;
 685                        } else if (strncmp(args[0].from, "lzo", 3) == 0) {
 686                                compress_type = "lzo";
 687                                info->compress_type = BTRFS_COMPRESS_LZO;
 688                                info->compress_level = 0;
 689                                btrfs_set_opt(info->mount_opt, COMPRESS);
 690                                btrfs_clear_opt(info->mount_opt, NODATACOW);
 691                                btrfs_clear_opt(info->mount_opt, NODATASUM);
 692                                btrfs_set_fs_incompat(info, COMPRESS_LZO);
 693                                no_compress = 0;
 694                        } else if (strncmp(args[0].from, "zstd", 4) == 0) {
 695                                compress_type = "zstd";
 696                                info->compress_type = BTRFS_COMPRESS_ZSTD;
 697                                info->compress_level =
 698                                        btrfs_compress_str2level(
 699                                                         BTRFS_COMPRESS_ZSTD,
 700                                                         args[0].from + 4);
 701                                btrfs_set_opt(info->mount_opt, COMPRESS);
 702                                btrfs_clear_opt(info->mount_opt, NODATACOW);
 703                                btrfs_clear_opt(info->mount_opt, NODATASUM);
 704                                btrfs_set_fs_incompat(info, COMPRESS_ZSTD);
 705                                no_compress = 0;
 706                        } else if (strncmp(args[0].from, "no", 2) == 0) {
 707                                compress_type = "no";
 708                                info->compress_level = 0;
 709                                info->compress_type = 0;
 710                                btrfs_clear_opt(info->mount_opt, COMPRESS);
 711                                btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
 712                                compress_force = false;
 713                                no_compress++;
 714                        } else {
 715                                ret = -EINVAL;
 716                                goto out;
 717                        }
 718
 719                        if (compress_force) {
 720                                btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
 721                        } else {
 722                                /*
 723                                 * If we remount from compress-force=xxx to
 724                                 * compress=xxx, we need clear FORCE_COMPRESS
 725                                 * flag, otherwise, there is no way for users
 726                                 * to disable forcible compression separately.
 727                                 */
 728                                btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
 729                        }
 730                        if (no_compress == 1) {
 731                                btrfs_info(info, "use no compression");
 732                        } else if ((info->compress_type != saved_compress_type) ||
 733                                   (compress_force != saved_compress_force) ||
 734                                   (info->compress_level != saved_compress_level)) {
 735                                btrfs_info(info, "%s %s compression, level %d",
 736                                           (compress_force) ? "force" : "use",
 737                                           compress_type, info->compress_level);
 738                        }
 739                        compress_force = false;
 740                        break;
 741                case Opt_ssd:
 742                        btrfs_set_and_info(info, SSD,
 743                                           "enabling ssd optimizations");
 744                        btrfs_clear_opt(info->mount_opt, NOSSD);
 745                        break;
 746                case Opt_ssd_spread:
 747                        btrfs_set_and_info(info, SSD,
 748                                           "enabling ssd optimizations");
 749                        btrfs_set_and_info(info, SSD_SPREAD,
 750                                           "using spread ssd allocation scheme");
 751                        btrfs_clear_opt(info->mount_opt, NOSSD);
 752                        break;
 753                case Opt_nossd:
 754                        btrfs_set_opt(info->mount_opt, NOSSD);
 755                        btrfs_clear_and_info(info, SSD,
 756                                             "not using ssd optimizations");
 757                        fallthrough;
 758                case Opt_nossd_spread:
 759                        btrfs_clear_and_info(info, SSD_SPREAD,
 760                                             "not using spread ssd allocation scheme");
 761                        break;
 762                case Opt_barrier:
 763                        btrfs_clear_and_info(info, NOBARRIER,
 764                                             "turning on barriers");
 765                        break;
 766                case Opt_nobarrier:
 767                        btrfs_set_and_info(info, NOBARRIER,
 768                                           "turning off barriers");
 769                        break;
 770                case Opt_thread_pool:
 771                        ret = match_int(&args[0], &intarg);
 772                        if (ret) {
 773                                goto out;
 774                        } else if (intarg == 0) {
 775                                ret = -EINVAL;
 776                                goto out;
 777                        }
 778                        info->thread_pool_size = intarg;
 779                        break;
 780                case Opt_max_inline:
 781                        num = match_strdup(&args[0]);
 782                        if (num) {
 783                                info->max_inline = memparse(num, NULL);
 784                                kfree(num);
 785
 786                                if (info->max_inline) {
 787                                        info->max_inline = min_t(u64,
 788                                                info->max_inline,
 789                                                info->sectorsize);
 790                                }
 791                                btrfs_info(info, "max_inline at %llu",
 792                                           info->max_inline);
 793                        } else {
 794                                ret = -ENOMEM;
 795                                goto out;
 796                        }
 797                        break;
 798                case Opt_acl:
 799#ifdef CONFIG_BTRFS_FS_POSIX_ACL
 800                        info->sb->s_flags |= SB_POSIXACL;
 801                        break;
 802#else
 803                        btrfs_err(info, "support for ACL not compiled in!");
 804                        ret = -EINVAL;
 805                        goto out;
 806#endif
 807                case Opt_noacl:
 808                        info->sb->s_flags &= ~SB_POSIXACL;
 809                        break;
 810                case Opt_notreelog:
 811                        btrfs_set_and_info(info, NOTREELOG,
 812                                           "disabling tree log");
 813                        break;
 814                case Opt_treelog:
 815                        btrfs_clear_and_info(info, NOTREELOG,
 816                                             "enabling tree log");
 817                        break;
 818                case Opt_norecovery:
 819                case Opt_nologreplay:
 820                        btrfs_warn(info,
 821                "'nologreplay' is deprecated, use 'rescue=nologreplay' instead");
 822                        btrfs_set_and_info(info, NOLOGREPLAY,
 823                                           "disabling log replay at mount time");
 824                        break;
 825                case Opt_flushoncommit:
 826                        btrfs_set_and_info(info, FLUSHONCOMMIT,
 827                                           "turning on flush-on-commit");
 828                        break;
 829                case Opt_noflushoncommit:
 830                        btrfs_clear_and_info(info, FLUSHONCOMMIT,
 831                                             "turning off flush-on-commit");
 832                        break;
 833                case Opt_ratio:
 834                        ret = match_int(&args[0], &intarg);
 835                        if (ret)
 836                                goto out;
 837                        info->metadata_ratio = intarg;
 838                        btrfs_info(info, "metadata ratio %u",
 839                                   info->metadata_ratio);
 840                        break;
 841                case Opt_discard:
 842                case Opt_discard_mode:
 843                        if (token == Opt_discard ||
 844                            strcmp(args[0].from, "sync") == 0) {
 845                                btrfs_clear_opt(info->mount_opt, DISCARD_ASYNC);
 846                                btrfs_set_and_info(info, DISCARD_SYNC,
 847                                                   "turning on sync discard");
 848                        } else if (strcmp(args[0].from, "async") == 0) {
 849                                btrfs_clear_opt(info->mount_opt, DISCARD_SYNC);
 850                                btrfs_set_and_info(info, DISCARD_ASYNC,
 851                                                   "turning on async discard");
 852                        } else {
 853                                ret = -EINVAL;
 854                                goto out;
 855                        }
 856                        break;
 857                case Opt_nodiscard:
 858                        btrfs_clear_and_info(info, DISCARD_SYNC,
 859                                             "turning off discard");
 860                        btrfs_clear_and_info(info, DISCARD_ASYNC,
 861                                             "turning off async discard");
 862                        break;
 863                case Opt_space_cache:
 864                case Opt_space_cache_version:
 865                        if (token == Opt_space_cache ||
 866                            strcmp(args[0].from, "v1") == 0) {
 867                                btrfs_clear_opt(info->mount_opt,
 868                                                FREE_SPACE_TREE);
 869                                btrfs_set_and_info(info, SPACE_CACHE,
 870                                           "enabling disk space caching");
 871                        } else if (strcmp(args[0].from, "v2") == 0) {
 872                                btrfs_clear_opt(info->mount_opt,
 873                                                SPACE_CACHE);
 874                                btrfs_set_and_info(info, FREE_SPACE_TREE,
 875                                                   "enabling free space tree");
 876                        } else {
 877                                ret = -EINVAL;
 878                                goto out;
 879                        }
 880                        break;
 881                case Opt_rescan_uuid_tree:
 882                        btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
 883                        break;
 884                case Opt_no_space_cache:
 885                        if (btrfs_test_opt(info, SPACE_CACHE)) {
 886                                btrfs_clear_and_info(info, SPACE_CACHE,
 887                                             "disabling disk space caching");
 888                        }
 889                        if (btrfs_test_opt(info, FREE_SPACE_TREE)) {
 890                                btrfs_clear_and_info(info, FREE_SPACE_TREE,
 891                                             "disabling free space tree");
 892                        }
 893                        break;
 894                case Opt_inode_cache:
 895                case Opt_noinode_cache:
 896                        btrfs_warn(info,
 897        "the 'inode_cache' option is deprecated and has no effect since 5.11");
 898                        break;
 899                case Opt_clear_cache:
 900                        btrfs_set_and_info(info, CLEAR_CACHE,
 901                                           "force clearing of disk cache");
 902                        break;
 903                case Opt_user_subvol_rm_allowed:
 904                        btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
 905                        break;
 906                case Opt_enospc_debug:
 907                        btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
 908                        break;
 909                case Opt_noenospc_debug:
 910                        btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
 911                        break;
 912                case Opt_defrag:
 913                        btrfs_set_and_info(info, AUTO_DEFRAG,
 914                                           "enabling auto defrag");
 915                        break;
 916                case Opt_nodefrag:
 917                        btrfs_clear_and_info(info, AUTO_DEFRAG,
 918                                             "disabling auto defrag");
 919                        break;
 920                case Opt_recovery:
 921                case Opt_usebackuproot:
 922                        btrfs_warn(info,
 923                        "'%s' is deprecated, use 'rescue=usebackuproot' instead",
 924                                   token == Opt_recovery ? "recovery" :
 925                                   "usebackuproot");
 926                        btrfs_info(info,
 927                                   "trying to use backup root at mount time");
 928                        btrfs_set_opt(info->mount_opt, USEBACKUPROOT);
 929                        break;
 930                case Opt_skip_balance:
 931                        btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
 932                        break;
 933#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
 934                case Opt_check_integrity_including_extent_data:
 935                        btrfs_info(info,
 936                                   "enabling check integrity including extent data");
 937                        btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY_DATA);
 938                        btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
 939                        break;
 940                case Opt_check_integrity:
 941                        btrfs_info(info, "enabling check integrity");
 942                        btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
 943                        break;
 944                case Opt_check_integrity_print_mask:
 945                        ret = match_int(&args[0], &intarg);
 946                        if (ret)
 947                                goto out;
 948                        info->check_integrity_print_mask = intarg;
 949                        btrfs_info(info, "check_integrity_print_mask 0x%x",
 950                                   info->check_integrity_print_mask);
 951                        break;
 952#else
 953                case Opt_check_integrity_including_extent_data:
 954                case Opt_check_integrity:
 955                case Opt_check_integrity_print_mask:
 956                        btrfs_err(info,
 957                                  "support for check_integrity* not compiled in!");
 958                        ret = -EINVAL;
 959                        goto out;
 960#endif
 961                case Opt_fatal_errors:
 962                        if (strcmp(args[0].from, "panic") == 0)
 963                                btrfs_set_opt(info->mount_opt,
 964                                              PANIC_ON_FATAL_ERROR);
 965                        else if (strcmp(args[0].from, "bug") == 0)
 966                                btrfs_clear_opt(info->mount_opt,
 967                                              PANIC_ON_FATAL_ERROR);
 968                        else {
 969                                ret = -EINVAL;
 970                                goto out;
 971                        }
 972                        break;
 973                case Opt_commit_interval:
 974                        intarg = 0;
 975                        ret = match_int(&args[0], &intarg);
 976                        if (ret)
 977                                goto out;
 978                        if (intarg == 0) {
 979                                btrfs_info(info,
 980                                           "using default commit interval %us",
 981                                           BTRFS_DEFAULT_COMMIT_INTERVAL);
 982                                intarg = BTRFS_DEFAULT_COMMIT_INTERVAL;
 983                        } else if (intarg > 300) {
 984                                btrfs_warn(info, "excessive commit interval %d",
 985                                           intarg);
 986                        }
 987                        info->commit_interval = intarg;
 988                        break;
 989                case Opt_rescue:
 990                        ret = parse_rescue_options(info, args[0].from);
 991                        if (ret < 0)
 992                                goto out;
 993                        break;
 994#ifdef CONFIG_BTRFS_DEBUG
 995                case Opt_fragment_all:
 996                        btrfs_info(info, "fragmenting all space");
 997                        btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
 998                        btrfs_set_opt(info->mount_opt, FRAGMENT_METADATA);
 999                        break;
1000                case Opt_fragment_metadata:
1001                        btrfs_info(info, "fragmenting metadata");
1002                        btrfs_set_opt(info->mount_opt,
1003                                      FRAGMENT_METADATA);
1004                        break;
1005                case Opt_fragment_data:
1006                        btrfs_info(info, "fragmenting data");
1007                        btrfs_set_opt(info->mount_opt, FRAGMENT_DATA);
1008                        break;
1009#endif
1010#ifdef CONFIG_BTRFS_FS_REF_VERIFY
1011                case Opt_ref_verify:
1012                        btrfs_info(info, "doing ref verification");
1013                        btrfs_set_opt(info->mount_opt, REF_VERIFY);
1014                        break;
1015#endif
1016                case Opt_err:
1017                        btrfs_err(info, "unrecognized mount option '%s'", p);
1018                        ret = -EINVAL;
1019                        goto out;
1020                default:
1021                        break;
1022                }
1023        }
1024check:
1025        /* We're read-only, don't have to check. */
1026        if (new_flags & SB_RDONLY)
1027                goto out;
1028
1029        if (check_ro_option(info, BTRFS_MOUNT_NOLOGREPLAY, "nologreplay") ||
1030            check_ro_option(info, BTRFS_MOUNT_IGNOREBADROOTS, "ignorebadroots") ||
1031            check_ro_option(info, BTRFS_MOUNT_IGNOREDATACSUMS, "ignoredatacsums"))
1032                ret = -EINVAL;
1033out:
1034        if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE) &&
1035            !btrfs_test_opt(info, FREE_SPACE_TREE) &&
1036            !btrfs_test_opt(info, CLEAR_CACHE)) {
1037                btrfs_err(info, "cannot disable free space tree");
1038                ret = -EINVAL;
1039
1040        }
1041        if (!ret)
1042                ret = btrfs_check_mountopts_zoned(info);
1043        if (!ret && btrfs_test_opt(info, SPACE_CACHE))
1044                btrfs_info(info, "disk space caching is enabled");
1045        if (!ret && btrfs_test_opt(info, FREE_SPACE_TREE))
1046                btrfs_info(info, "using free space tree");
1047        return ret;
1048}
1049
1050/*
1051 * Parse mount options that are required early in the mount process.
1052 *
1053 * All other options will be parsed on much later in the mount process and
1054 * only when we need to allocate a new super block.
1055 */
1056static int btrfs_parse_device_options(const char *options, fmode_t flags,
1057                                      void *holder)
1058{
1059        substring_t args[MAX_OPT_ARGS];
1060        char *device_name, *opts, *orig, *p;
1061        struct btrfs_device *device = NULL;
1062        int error = 0;
1063
1064        lockdep_assert_held(&uuid_mutex);
1065
1066        if (!options)
1067                return 0;
1068
1069        /*
1070         * strsep changes the string, duplicate it because btrfs_parse_options
1071         * gets called later
1072         */
1073        opts = kstrdup(options, GFP_KERNEL);
1074        if (!opts)
1075                return -ENOMEM;
1076        orig = opts;
1077
1078        while ((p = strsep(&opts, ",")) != NULL) {
1079                int token;
1080
1081                if (!*p)
1082                        continue;
1083
1084                token = match_token(p, tokens, args);
1085                if (token == Opt_device) {
1086                        device_name = match_strdup(&args[0]);
1087                        if (!device_name) {
1088                                error = -ENOMEM;
1089                                goto out;
1090                        }
1091                        device = btrfs_scan_one_device(device_name, flags,
1092                                        holder);
1093                        kfree(device_name);
1094                        if (IS_ERR(device)) {
1095                                error = PTR_ERR(device);
1096                                goto out;
1097                        }
1098                }
1099        }
1100
1101out:
1102        kfree(orig);
1103        return error;
1104}
1105
1106/*
1107 * Parse mount options that are related to subvolume id
1108 *
1109 * The value is later passed to mount_subvol()
1110 */
1111static int btrfs_parse_subvol_options(const char *options, char **subvol_name,
1112                u64 *subvol_objectid)
1113{
1114        substring_t args[MAX_OPT_ARGS];
1115        char *opts, *orig, *p;
1116        int error = 0;
1117        u64 subvolid;
1118
1119        if (!options)
1120                return 0;
1121
1122        /*
1123         * strsep changes the string, duplicate it because
1124         * btrfs_parse_device_options gets called later
1125         */
1126        opts = kstrdup(options, GFP_KERNEL);
1127        if (!opts)
1128                return -ENOMEM;
1129        orig = opts;
1130
1131        while ((p = strsep(&opts, ",")) != NULL) {
1132                int token;
1133                if (!*p)
1134                        continue;
1135
1136                token = match_token(p, tokens, args);
1137                switch (token) {
1138                case Opt_subvol:
1139                        kfree(*subvol_name);
1140                        *subvol_name = match_strdup(&args[0]);
1141                        if (!*subvol_name) {
1142                                error = -ENOMEM;
1143                                goto out;
1144                        }
1145                        break;
1146                case Opt_subvolid:
1147                        error = match_u64(&args[0], &subvolid);
1148                        if (error)
1149                                goto out;
1150
1151                        /* we want the original fs_tree */
1152                        if (subvolid == 0)
1153                                subvolid = BTRFS_FS_TREE_OBJECTID;
1154
1155                        *subvol_objectid = subvolid;
1156                        break;
1157                default:
1158                        break;
1159                }
1160        }
1161
1162out:
1163        kfree(orig);
1164        return error;
1165}
1166
1167char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
1168                                          u64 subvol_objectid)
1169{
1170        struct btrfs_root *root = fs_info->tree_root;
1171        struct btrfs_root *fs_root = NULL;
1172        struct btrfs_root_ref *root_ref;
1173        struct btrfs_inode_ref *inode_ref;
1174        struct btrfs_key key;
1175        struct btrfs_path *path = NULL;
1176        char *name = NULL, *ptr;
1177        u64 dirid;
1178        int len;
1179        int ret;
1180
1181        path = btrfs_alloc_path();
1182        if (!path) {
1183                ret = -ENOMEM;
1184                goto err;
1185        }
1186
1187        name = kmalloc(PATH_MAX, GFP_KERNEL);
1188        if (!name) {
1189                ret = -ENOMEM;
1190                goto err;
1191        }
1192        ptr = name + PATH_MAX - 1;
1193        ptr[0] = '\0';
1194
1195        /*
1196         * Walk up the subvolume trees in the tree of tree roots by root
1197         * backrefs until we hit the top-level subvolume.
1198         */
1199        while (subvol_objectid != BTRFS_FS_TREE_OBJECTID) {
1200                key.objectid = subvol_objectid;
1201                key.type = BTRFS_ROOT_BACKREF_KEY;
1202                key.offset = (u64)-1;
1203
1204                ret = btrfs_search_backwards(root, &key, path);
1205                if (ret < 0) {
1206                        goto err;
1207                } else if (ret > 0) {
1208                        ret = -ENOENT;
1209                        goto err;
1210                }
1211
1212                subvol_objectid = key.offset;
1213
1214                root_ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
1215                                          struct btrfs_root_ref);
1216                len = btrfs_root_ref_name_len(path->nodes[0], root_ref);
1217                ptr -= len + 1;
1218                if (ptr < name) {
1219                        ret = -ENAMETOOLONG;
1220                        goto err;
1221                }
1222                read_extent_buffer(path->nodes[0], ptr + 1,
1223                                   (unsigned long)(root_ref + 1), len);
1224                ptr[0] = '/';
1225                dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref);
1226                btrfs_release_path(path);
1227
1228                fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true);
1229                if (IS_ERR(fs_root)) {
1230                        ret = PTR_ERR(fs_root);
1231                        fs_root = NULL;
1232                        goto err;
1233                }
1234
1235                /*
1236                 * Walk up the filesystem tree by inode refs until we hit the
1237                 * root directory.
1238                 */
1239                while (dirid != BTRFS_FIRST_FREE_OBJECTID) {
1240                        key.objectid = dirid;
1241                        key.type = BTRFS_INODE_REF_KEY;
1242                        key.offset = (u64)-1;
1243
1244                        ret = btrfs_search_backwards(fs_root, &key, path);
1245                        if (ret < 0) {
1246                                goto err;
1247                        } else if (ret > 0) {
1248                                ret = -ENOENT;
1249                                goto err;
1250                        }
1251
1252                        dirid = key.offset;
1253
1254                        inode_ref = btrfs_item_ptr(path->nodes[0],
1255                                                   path->slots[0],
1256                                                   struct btrfs_inode_ref);
1257                        len = btrfs_inode_ref_name_len(path->nodes[0],
1258                                                       inode_ref);
1259                        ptr -= len + 1;
1260                        if (ptr < name) {
1261                                ret = -ENAMETOOLONG;
1262                                goto err;
1263                        }
1264                        read_extent_buffer(path->nodes[0], ptr + 1,
1265                                           (unsigned long)(inode_ref + 1), len);
1266                        ptr[0] = '/';
1267                        btrfs_release_path(path);
1268                }
1269                btrfs_put_root(fs_root);
1270                fs_root = NULL;
1271        }
1272
1273        btrfs_free_path(path);
1274        if (ptr == name + PATH_MAX - 1) {
1275                name[0] = '/';
1276                name[1] = '\0';
1277        } else {
1278                memmove(name, ptr, name + PATH_MAX - ptr);
1279        }
1280        return name;
1281
1282err:
1283        btrfs_put_root(fs_root);
1284        btrfs_free_path(path);
1285        kfree(name);
1286        return ERR_PTR(ret);
1287}
1288
1289static int get_default_subvol_objectid(struct btrfs_fs_info *fs_info, u64 *objectid)
1290{
1291        struct btrfs_root *root = fs_info->tree_root;
1292        struct btrfs_dir_item *di;
1293        struct btrfs_path *path;
1294        struct btrfs_key location;
1295        u64 dir_id;
1296
1297        path = btrfs_alloc_path();
1298        if (!path)
1299                return -ENOMEM;
1300
1301        /*
1302         * Find the "default" dir item which points to the root item that we
1303         * will mount by default if we haven't been given a specific subvolume
1304         * to mount.
1305         */
1306        dir_id = btrfs_super_root_dir(fs_info->super_copy);
1307        di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
1308        if (IS_ERR(di)) {
1309                btrfs_free_path(path);
1310                return PTR_ERR(di);
1311        }
1312        if (!di) {
1313                /*
1314                 * Ok the default dir item isn't there.  This is weird since
1315                 * it's always been there, but don't freak out, just try and
1316                 * mount the top-level subvolume.
1317                 */
1318                btrfs_free_path(path);
1319                *objectid = BTRFS_FS_TREE_OBJECTID;
1320                return 0;
1321        }
1322
1323        btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
1324        btrfs_free_path(path);
1325        *objectid = location.objectid;
1326        return 0;
1327}
1328
1329static int btrfs_fill_super(struct super_block *sb,
1330                            struct btrfs_fs_devices *fs_devices,
1331                            void *data)
1332{
1333        struct inode *inode;
1334        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1335        int err;
1336
1337        sb->s_maxbytes = MAX_LFS_FILESIZE;
1338        sb->s_magic = BTRFS_SUPER_MAGIC;
1339        sb->s_op = &btrfs_super_ops;
1340        sb->s_d_op = &btrfs_dentry_operations;
1341        sb->s_export_op = &btrfs_export_ops;
1342#ifdef CONFIG_FS_VERITY
1343        sb->s_vop = &btrfs_verityops;
1344#endif
1345        sb->s_xattr = btrfs_xattr_handlers;
1346        sb->s_time_gran = 1;
1347#ifdef CONFIG_BTRFS_FS_POSIX_ACL
1348        sb->s_flags |= SB_POSIXACL;
1349#endif
1350        sb->s_flags |= SB_I_VERSION;
1351        sb->s_iflags |= SB_I_CGROUPWB;
1352
1353        err = super_setup_bdi(sb);
1354        if (err) {
1355                btrfs_err(fs_info, "super_setup_bdi failed");
1356                return err;
1357        }
1358
1359        err = open_ctree(sb, fs_devices, (char *)data);
1360        if (err) {
1361                btrfs_err(fs_info, "open_ctree failed");
1362                return err;
1363        }
1364
1365        inode = btrfs_iget(sb, BTRFS_FIRST_FREE_OBJECTID, fs_info->fs_root);
1366        if (IS_ERR(inode)) {
1367                err = PTR_ERR(inode);
1368                goto fail_close;
1369        }
1370
1371        sb->s_root = d_make_root(inode);
1372        if (!sb->s_root) {
1373                err = -ENOMEM;
1374                goto fail_close;
1375        }
1376
1377        cleancache_init_fs(sb);
1378        sb->s_flags |= SB_ACTIVE;
1379        return 0;
1380
1381fail_close:
1382        close_ctree(fs_info);
1383        return err;
1384}
1385
1386int btrfs_sync_fs(struct super_block *sb, int wait)
1387{
1388        struct btrfs_trans_handle *trans;
1389        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1390        struct btrfs_root *root = fs_info->tree_root;
1391
1392        trace_btrfs_sync_fs(fs_info, wait);
1393
1394        if (!wait) {
1395                filemap_flush(fs_info->btree_inode->i_mapping);
1396                return 0;
1397        }
1398
1399        btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
1400
1401        trans = btrfs_attach_transaction_barrier(root);
1402        if (IS_ERR(trans)) {
1403                /* no transaction, don't bother */
1404                if (PTR_ERR(trans) == -ENOENT) {
1405                        /*
1406                         * Exit unless we have some pending changes
1407                         * that need to go through commit
1408                         */
1409                        if (fs_info->pending_changes == 0)
1410                                return 0;
1411                        /*
1412                         * A non-blocking test if the fs is frozen. We must not
1413                         * start a new transaction here otherwise a deadlock
1414                         * happens. The pending operations are delayed to the
1415                         * next commit after thawing.
1416                         */
1417                        if (sb_start_write_trylock(sb))
1418                                sb_end_write(sb);
1419                        else
1420                                return 0;
1421                        trans = btrfs_start_transaction(root, 0);
1422                }
1423                if (IS_ERR(trans))
1424                        return PTR_ERR(trans);
1425        }
1426        return btrfs_commit_transaction(trans);
1427}
1428
1429static void print_rescue_option(struct seq_file *seq, const char *s, bool *printed)
1430{
1431        seq_printf(seq, "%s%s", (*printed) ? ":" : ",rescue=", s);
1432        *printed = true;
1433}
1434
1435static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
1436{
1437        struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
1438        const char *compress_type;
1439        const char *subvol_name;
1440        bool printed = false;
1441
1442        if (btrfs_test_opt(info, DEGRADED))
1443                seq_puts(seq, ",degraded");
1444        if (btrfs_test_opt(info, NODATASUM))
1445                seq_puts(seq, ",nodatasum");
1446        if (btrfs_test_opt(info, NODATACOW))
1447                seq_puts(seq, ",nodatacow");
1448        if (btrfs_test_opt(info, NOBARRIER))
1449                seq_puts(seq, ",nobarrier");
1450        if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE)
1451                seq_printf(seq, ",max_inline=%llu", info->max_inline);
1452        if (info->thread_pool_size !=  min_t(unsigned long,
1453                                             num_online_cpus() + 2, 8))
1454                seq_printf(seq, ",thread_pool=%u", info->thread_pool_size);
1455        if (btrfs_test_opt(info, COMPRESS)) {
1456                compress_type = btrfs_compress_type2str(info->compress_type);
1457                if (btrfs_test_opt(info, FORCE_COMPRESS))
1458                        seq_printf(seq, ",compress-force=%s", compress_type);
1459                else
1460                        seq_printf(seq, ",compress=%s", compress_type);
1461                if (info->compress_level)
1462                        seq_printf(seq, ":%d", info->compress_level);
1463        }
1464        if (btrfs_test_opt(info, NOSSD))
1465                seq_puts(seq, ",nossd");
1466        if (btrfs_test_opt(info, SSD_SPREAD))
1467                seq_puts(seq, ",ssd_spread");
1468        else if (btrfs_test_opt(info, SSD))
1469                seq_puts(seq, ",ssd");
1470        if (btrfs_test_opt(info, NOTREELOG))
1471                seq_puts(seq, ",notreelog");
1472        if (btrfs_test_opt(info, NOLOGREPLAY))
1473                print_rescue_option(seq, "nologreplay", &printed);
1474        if (btrfs_test_opt(info, USEBACKUPROOT))
1475                print_rescue_option(seq, "usebackuproot", &printed);
1476        if (btrfs_test_opt(info, IGNOREBADROOTS))
1477                print_rescue_option(seq, "ignorebadroots", &printed);
1478        if (btrfs_test_opt(info, IGNOREDATACSUMS))
1479                print_rescue_option(seq, "ignoredatacsums", &printed);
1480        if (btrfs_test_opt(info, FLUSHONCOMMIT))
1481                seq_puts(seq, ",flushoncommit");
1482        if (btrfs_test_opt(info, DISCARD_SYNC))
1483                seq_puts(seq, ",discard");
1484        if (btrfs_test_opt(info, DISCARD_ASYNC))
1485                seq_puts(seq, ",discard=async");
1486        if (!(info->sb->s_flags & SB_POSIXACL))
1487                seq_puts(seq, ",noacl");
1488        if (btrfs_free_space_cache_v1_active(info))
1489                seq_puts(seq, ",space_cache");
1490        else if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
1491                seq_puts(seq, ",space_cache=v2");
1492        else
1493                seq_puts(seq, ",nospace_cache");
1494        if (btrfs_test_opt(info, RESCAN_UUID_TREE))
1495                seq_puts(seq, ",rescan_uuid_tree");
1496        if (btrfs_test_opt(info, CLEAR_CACHE))
1497                seq_puts(seq, ",clear_cache");
1498        if (btrfs_test_opt(info, USER_SUBVOL_RM_ALLOWED))
1499                seq_puts(seq, ",user_subvol_rm_allowed");
1500        if (btrfs_test_opt(info, ENOSPC_DEBUG))
1501                seq_puts(seq, ",enospc_debug");
1502        if (btrfs_test_opt(info, AUTO_DEFRAG))
1503                seq_puts(seq, ",autodefrag");
1504        if (btrfs_test_opt(info, SKIP_BALANCE))
1505                seq_puts(seq, ",skip_balance");
1506#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1507        if (btrfs_test_opt(info, CHECK_INTEGRITY_DATA))
1508                seq_puts(seq, ",check_int_data");
1509        else if (btrfs_test_opt(info, CHECK_INTEGRITY))
1510                seq_puts(seq, ",check_int");
1511        if (info->check_integrity_print_mask)
1512                seq_printf(seq, ",check_int_print_mask=%d",
1513                                info->check_integrity_print_mask);
1514#endif
1515        if (info->metadata_ratio)
1516                seq_printf(seq, ",metadata_ratio=%u", info->metadata_ratio);
1517        if (btrfs_test_opt(info, PANIC_ON_FATAL_ERROR))
1518                seq_puts(seq, ",fatal_errors=panic");
1519        if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
1520                seq_printf(seq, ",commit=%u", info->commit_interval);
1521#ifdef CONFIG_BTRFS_DEBUG
1522        if (btrfs_test_opt(info, FRAGMENT_DATA))
1523                seq_puts(seq, ",fragment=data");
1524        if (btrfs_test_opt(info, FRAGMENT_METADATA))
1525                seq_puts(seq, ",fragment=metadata");
1526#endif
1527        if (btrfs_test_opt(info, REF_VERIFY))
1528                seq_puts(seq, ",ref_verify");
1529        seq_printf(seq, ",subvolid=%llu",
1530                  BTRFS_I(d_inode(dentry))->root->root_key.objectid);
1531        subvol_name = btrfs_get_subvol_name_from_objectid(info,
1532                        BTRFS_I(d_inode(dentry))->root->root_key.objectid);
1533        if (!IS_ERR(subvol_name)) {
1534                seq_puts(seq, ",subvol=");
1535                seq_escape(seq, subvol_name, " \t\n\\");
1536                kfree(subvol_name);
1537        }
1538        return 0;
1539}
1540
1541static int btrfs_test_super(struct super_block *s, void *data)
1542{
1543        struct btrfs_fs_info *p = data;
1544        struct btrfs_fs_info *fs_info = btrfs_sb(s);
1545
1546        return fs_info->fs_devices == p->fs_devices;
1547}
1548
1549static int btrfs_set_super(struct super_block *s, void *data)
1550{
1551        int err = set_anon_super(s, data);
1552        if (!err)
1553                s->s_fs_info = data;
1554        return err;
1555}
1556
1557/*
1558 * subvolumes are identified by ino 256
1559 */
1560static inline int is_subvolume_inode(struct inode *inode)
1561{
1562        if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
1563                return 1;
1564        return 0;
1565}
1566
1567static struct dentry *mount_subvol(const char *subvol_name, u64 subvol_objectid,
1568                                   struct vfsmount *mnt)
1569{
1570        struct dentry *root;
1571        int ret;
1572
1573        if (!subvol_name) {
1574                if (!subvol_objectid) {
1575                        ret = get_default_subvol_objectid(btrfs_sb(mnt->mnt_sb),
1576                                                          &subvol_objectid);
1577                        if (ret) {
1578                                root = ERR_PTR(ret);
1579                                goto out;
1580                        }
1581                }
1582                subvol_name = btrfs_get_subvol_name_from_objectid(
1583                                        btrfs_sb(mnt->mnt_sb), subvol_objectid);
1584                if (IS_ERR(subvol_name)) {
1585                        root = ERR_CAST(subvol_name);
1586                        subvol_name = NULL;
1587                        goto out;
1588                }
1589
1590        }
1591
1592        root = mount_subtree(mnt, subvol_name);
1593        /* mount_subtree() drops our reference on the vfsmount. */
1594        mnt = NULL;
1595
1596        if (!IS_ERR(root)) {
1597                struct super_block *s = root->d_sb;
1598                struct btrfs_fs_info *fs_info = btrfs_sb(s);
1599                struct inode *root_inode = d_inode(root);
1600                u64 root_objectid = BTRFS_I(root_inode)->root->root_key.objectid;
1601
1602                ret = 0;
1603                if (!is_subvolume_inode(root_inode)) {
1604                        btrfs_err(fs_info, "'%s' is not a valid subvolume",
1605                               subvol_name);
1606                        ret = -EINVAL;
1607                }
1608                if (subvol_objectid && root_objectid != subvol_objectid) {
1609                        /*
1610                         * This will also catch a race condition where a
1611                         * subvolume which was passed by ID is renamed and
1612                         * another subvolume is renamed over the old location.
1613                         */
1614                        btrfs_err(fs_info,
1615                                  "subvol '%s' does not match subvolid %llu",
1616                                  subvol_name, subvol_objectid);
1617                        ret = -EINVAL;
1618                }
1619                if (ret) {
1620                        dput(root);
1621                        root = ERR_PTR(ret);
1622                        deactivate_locked_super(s);
1623                }
1624        }
1625
1626out:
1627        mntput(mnt);
1628        kfree(subvol_name);
1629        return root;
1630}
1631
1632/*
1633 * Find a superblock for the given device / mount point.
1634 *
1635 * Note: This is based on mount_bdev from fs/super.c with a few additions
1636 *       for multiple device setup.  Make sure to keep it in sync.
1637 */
1638static struct dentry *btrfs_mount_root(struct file_system_type *fs_type,
1639                int flags, const char *device_name, void *data)
1640{
1641        struct block_device *bdev = NULL;
1642        struct super_block *s;
1643        struct btrfs_device *device = NULL;
1644        struct btrfs_fs_devices *fs_devices = NULL;
1645        struct btrfs_fs_info *fs_info = NULL;
1646        void *new_sec_opts = NULL;
1647        fmode_t mode = FMODE_READ;
1648        int error = 0;
1649
1650        if (!(flags & SB_RDONLY))
1651                mode |= FMODE_WRITE;
1652
1653        if (data) {
1654                error = security_sb_eat_lsm_opts(data, &new_sec_opts);
1655                if (error)
1656                        return ERR_PTR(error);
1657        }
1658
1659        /*
1660         * Setup a dummy root and fs_info for test/set super.  This is because
1661         * we don't actually fill this stuff out until open_ctree, but we need
1662         * then open_ctree will properly initialize the file system specific
1663         * settings later.  btrfs_init_fs_info initializes the static elements
1664         * of the fs_info (locks and such) to make cleanup easier if we find a
1665         * superblock with our given fs_devices later on at sget() time.
1666         */
1667        fs_info = kvzalloc(sizeof(struct btrfs_fs_info), GFP_KERNEL);
1668        if (!fs_info) {
1669                error = -ENOMEM;
1670                goto error_sec_opts;
1671        }
1672        btrfs_init_fs_info(fs_info);
1673
1674        fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
1675        fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_KERNEL);
1676        if (!fs_info->super_copy || !fs_info->super_for_commit) {
1677                error = -ENOMEM;
1678                goto error_fs_info;
1679        }
1680
1681        mutex_lock(&uuid_mutex);
1682        error = btrfs_parse_device_options(data, mode, fs_type);
1683        if (error) {
1684                mutex_unlock(&uuid_mutex);
1685                goto error_fs_info;
1686        }
1687
1688        device = btrfs_scan_one_device(device_name, mode, fs_type);
1689        if (IS_ERR(device)) {
1690                mutex_unlock(&uuid_mutex);
1691                error = PTR_ERR(device);
1692                goto error_fs_info;
1693        }
1694
1695        fs_devices = device->fs_devices;
1696        fs_info->fs_devices = fs_devices;
1697
1698        error = btrfs_open_devices(fs_devices, mode, fs_type);
1699        mutex_unlock(&uuid_mutex);
1700        if (error)
1701                goto error_fs_info;
1702
1703        if (!(flags & SB_RDONLY) && fs_devices->rw_devices == 0) {
1704                error = -EACCES;
1705                goto error_close_devices;
1706        }
1707
1708        bdev = fs_devices->latest_dev->bdev;
1709        s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | SB_NOSEC,
1710                 fs_info);
1711        if (IS_ERR(s)) {
1712                error = PTR_ERR(s);
1713                goto error_close_devices;
1714        }
1715
1716        if (s->s_root) {
1717                btrfs_close_devices(fs_devices);
1718                btrfs_free_fs_info(fs_info);
1719                if ((flags ^ s->s_flags) & SB_RDONLY)
1720                        error = -EBUSY;
1721        } else {
1722                snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
1723                btrfs_sb(s)->bdev_holder = fs_type;
1724                if (!strstr(crc32c_impl(), "generic"))
1725                        set_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags);
1726                error = btrfs_fill_super(s, fs_devices, data);
1727        }
1728        if (!error)
1729                error = security_sb_set_mnt_opts(s, new_sec_opts, 0, NULL);
1730        security_free_mnt_opts(&new_sec_opts);
1731        if (error) {
1732                deactivate_locked_super(s);
1733                return ERR_PTR(error);
1734        }
1735
1736        return dget(s->s_root);
1737
1738error_close_devices:
1739        btrfs_close_devices(fs_devices);
1740error_fs_info:
1741        btrfs_free_fs_info(fs_info);
1742error_sec_opts:
1743        security_free_mnt_opts(&new_sec_opts);
1744        return ERR_PTR(error);
1745}
1746
1747/*
1748 * Mount function which is called by VFS layer.
1749 *
1750 * In order to allow mounting a subvolume directly, btrfs uses mount_subtree()
1751 * which needs vfsmount* of device's root (/).  This means device's root has to
1752 * be mounted internally in any case.
1753 *
1754 * Operation flow:
1755 *   1. Parse subvol id related options for later use in mount_subvol().
1756 *
1757 *   2. Mount device's root (/) by calling vfs_kern_mount().
1758 *
1759 *      NOTE: vfs_kern_mount() is used by VFS to call btrfs_mount() in the
1760 *      first place. In order to avoid calling btrfs_mount() again, we use
1761 *      different file_system_type which is not registered to VFS by
1762 *      register_filesystem() (btrfs_root_fs_type). As a result,
1763 *      btrfs_mount_root() is called. The return value will be used by
1764 *      mount_subtree() in mount_subvol().
1765 *
1766 *   3. Call mount_subvol() to get the dentry of subvolume. Since there is
1767 *      "btrfs subvolume set-default", mount_subvol() is called always.
1768 */
1769static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1770                const char *device_name, void *data)
1771{
1772        struct vfsmount *mnt_root;
1773        struct dentry *root;
1774        char *subvol_name = NULL;
1775        u64 subvol_objectid = 0;
1776        int error = 0;
1777
1778        error = btrfs_parse_subvol_options(data, &subvol_name,
1779                                        &subvol_objectid);
1780        if (error) {
1781                kfree(subvol_name);
1782                return ERR_PTR(error);
1783        }
1784
1785        /* mount device's root (/) */
1786        mnt_root = vfs_kern_mount(&btrfs_root_fs_type, flags, device_name, data);
1787        if (PTR_ERR_OR_ZERO(mnt_root) == -EBUSY) {
1788                if (flags & SB_RDONLY) {
1789                        mnt_root = vfs_kern_mount(&btrfs_root_fs_type,
1790                                flags & ~SB_RDONLY, device_name, data);
1791                } else {
1792                        mnt_root = vfs_kern_mount(&btrfs_root_fs_type,
1793                                flags | SB_RDONLY, device_name, data);
1794                        if (IS_ERR(mnt_root)) {
1795                                root = ERR_CAST(mnt_root);
1796                                kfree(subvol_name);
1797                                goto out;
1798                        }
1799
1800                        down_write(&mnt_root->mnt_sb->s_umount);
1801                        error = btrfs_remount(mnt_root->mnt_sb, &flags, NULL);
1802                        up_write(&mnt_root->mnt_sb->s_umount);
1803                        if (error < 0) {
1804                                root = ERR_PTR(error);
1805                                mntput(mnt_root);
1806                                kfree(subvol_name);
1807                                goto out;
1808                        }
1809                }
1810        }
1811        if (IS_ERR(mnt_root)) {
1812                root = ERR_CAST(mnt_root);
1813                kfree(subvol_name);
1814                goto out;
1815        }
1816
1817        /* mount_subvol() will free subvol_name and mnt_root */
1818        root = mount_subvol(subvol_name, subvol_objectid, mnt_root);
1819
1820out:
1821        return root;
1822}
1823
1824static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
1825                                     u32 new_pool_size, u32 old_pool_size)
1826{
1827        if (new_pool_size == old_pool_size)
1828                return;
1829
1830        fs_info->thread_pool_size = new_pool_size;
1831
1832        btrfs_info(fs_info, "resize thread pool %d -> %d",
1833               old_pool_size, new_pool_size);
1834
1835        btrfs_workqueue_set_max(fs_info->workers, new_pool_size);
1836        btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);
1837        btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);
1838        btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size);
1839        btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size);
1840        btrfs_workqueue_set_max(fs_info->endio_meta_write_workers,
1841                                new_pool_size);
1842        btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);
1843        btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);
1844        btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);
1845        btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size);
1846        btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers,
1847                                new_pool_size);
1848}
1849
1850static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
1851                                       unsigned long old_opts, int flags)
1852{
1853        if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1854            (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1855             (flags & SB_RDONLY))) {
1856                /* wait for any defraggers to finish */
1857                wait_event(fs_info->transaction_wait,
1858                           (atomic_read(&fs_info->defrag_running) == 0));
1859                if (flags & SB_RDONLY)
1860                        sync_filesystem(fs_info->sb);
1861        }
1862}
1863
1864static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,
1865                                         unsigned long old_opts)
1866{
1867        const bool cache_opt = btrfs_test_opt(fs_info, SPACE_CACHE);
1868
1869        /*
1870         * We need to cleanup all defragable inodes if the autodefragment is
1871         * close or the filesystem is read only.
1872         */
1873        if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1874            (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) || sb_rdonly(fs_info->sb))) {
1875                btrfs_cleanup_defrag_inodes(fs_info);
1876        }
1877
1878        /* If we toggled discard async */
1879        if (!btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) &&
1880            btrfs_test_opt(fs_info, DISCARD_ASYNC))
1881                btrfs_discard_resume(fs_info);
1882        else if (btrfs_raw_test_opt(old_opts, DISCARD_ASYNC) &&
1883                 !btrfs_test_opt(fs_info, DISCARD_ASYNC))
1884                btrfs_discard_cleanup(fs_info);
1885
1886        /* If we toggled space cache */
1887        if (cache_opt != btrfs_free_space_cache_v1_active(fs_info))
1888                btrfs_set_free_space_cache_v1_active(fs_info, cache_opt);
1889}
1890
1891static int btrfs_remount(struct super_block *sb, int *flags, char *data)
1892{
1893        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1894        unsigned old_flags = sb->s_flags;
1895        unsigned long old_opts = fs_info->mount_opt;
1896        unsigned long old_compress_type = fs_info->compress_type;
1897        u64 old_max_inline = fs_info->max_inline;
1898        u32 old_thread_pool_size = fs_info->thread_pool_size;
1899        u32 old_metadata_ratio = fs_info->metadata_ratio;
1900        int ret;
1901
1902        sync_filesystem(sb);
1903        set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1904
1905        if (data) {
1906                void *new_sec_opts = NULL;
1907
1908                ret = security_sb_eat_lsm_opts(data, &new_sec_opts);
1909                if (!ret)
1910                        ret = security_sb_remount(sb, new_sec_opts);
1911                security_free_mnt_opts(&new_sec_opts);
1912                if (ret)
1913                        goto restore;
1914        }
1915
1916        ret = btrfs_parse_options(fs_info, data, *flags);
1917        if (ret)
1918                goto restore;
1919
1920        btrfs_remount_begin(fs_info, old_opts, *flags);
1921        btrfs_resize_thread_pool(fs_info,
1922                fs_info->thread_pool_size, old_thread_pool_size);
1923
1924        if ((bool)btrfs_test_opt(fs_info, FREE_SPACE_TREE) !=
1925            (bool)btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
1926            (!sb_rdonly(sb) || (*flags & SB_RDONLY))) {
1927                btrfs_warn(fs_info,
1928                "remount supports changing free space tree only from ro to rw");
1929                /* Make sure free space cache options match the state on disk */
1930                if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
1931                        btrfs_set_opt(fs_info->mount_opt, FREE_SPACE_TREE);
1932                        btrfs_clear_opt(fs_info->mount_opt, SPACE_CACHE);
1933                }
1934                if (btrfs_free_space_cache_v1_active(fs_info)) {
1935                        btrfs_clear_opt(fs_info->mount_opt, FREE_SPACE_TREE);
1936                        btrfs_set_opt(fs_info->mount_opt, SPACE_CACHE);
1937                }
1938        }
1939
1940        if ((bool)(*flags & SB_RDONLY) == sb_rdonly(sb))
1941                goto out;
1942
1943        if (*flags & SB_RDONLY) {
1944                /*
1945                 * this also happens on 'umount -rf' or on shutdown, when
1946                 * the filesystem is busy.
1947                 */
1948                cancel_work_sync(&fs_info->async_reclaim_work);
1949                cancel_work_sync(&fs_info->async_data_reclaim_work);
1950
1951                btrfs_discard_cleanup(fs_info);
1952
1953                /* wait for the uuid_scan task to finish */
1954                down(&fs_info->uuid_tree_rescan_sem);
1955                /* avoid complains from lockdep et al. */
1956                up(&fs_info->uuid_tree_rescan_sem);
1957
1958                btrfs_set_sb_rdonly(sb);
1959
1960                /*
1961                 * Setting SB_RDONLY will put the cleaner thread to
1962                 * sleep at the next loop if it's already active.
1963                 * If it's already asleep, we'll leave unused block
1964                 * groups on disk until we're mounted read-write again
1965                 * unless we clean them up here.
1966                 */
1967                btrfs_delete_unused_bgs(fs_info);
1968
1969                /*
1970                 * The cleaner task could be already running before we set the
1971                 * flag BTRFS_FS_STATE_RO (and SB_RDONLY in the superblock).
1972                 * We must make sure that after we finish the remount, i.e. after
1973                 * we call btrfs_commit_super(), the cleaner can no longer start
1974                 * a transaction - either because it was dropping a dead root,
1975                 * running delayed iputs or deleting an unused block group (the
1976                 * cleaner picked a block group from the list of unused block
1977                 * groups before we were able to in the previous call to
1978                 * btrfs_delete_unused_bgs()).
1979                 */
1980                wait_on_bit(&fs_info->flags, BTRFS_FS_CLEANER_RUNNING,
1981                            TASK_UNINTERRUPTIBLE);
1982
1983                /*
1984                 * We've set the superblock to RO mode, so we might have made
1985                 * the cleaner task sleep without running all pending delayed
1986                 * iputs. Go through all the delayed iputs here, so that if an
1987                 * unmount happens without remounting RW we don't end up at
1988                 * finishing close_ctree() with a non-empty list of delayed
1989                 * iputs.
1990                 */
1991                btrfs_run_delayed_iputs(fs_info);
1992
1993                btrfs_dev_replace_suspend_for_unmount(fs_info);
1994                btrfs_scrub_cancel(fs_info);
1995                btrfs_pause_balance(fs_info);
1996
1997                /*
1998                 * Pause the qgroup rescan worker if it is running. We don't want
1999                 * it to be still running after we are in RO mode, as after that,
2000                 * by the time we unmount, it might have left a transaction open,
2001                 * so we would leak the transaction and/or crash.
2002                 */
2003                btrfs_qgroup_wait_for_completion(fs_info, false);
2004
2005                ret = btrfs_commit_super(fs_info);
2006                if (ret)
2007                        goto restore;
2008        } else {
2009                if (BTRFS_FS_ERROR(fs_info)) {
2010                        btrfs_err(fs_info,
2011                                "Remounting read-write after error is not allowed");
2012                        ret = -EINVAL;
2013                        goto restore;
2014                }
2015                if (fs_info->fs_devices->rw_devices == 0) {
2016                        ret = -EACCES;
2017                        goto restore;
2018                }
2019
2020                if (!btrfs_check_rw_degradable(fs_info, NULL)) {
2021                        btrfs_warn(fs_info,
2022                "too many missing devices, writable remount is not allowed");
2023                        ret = -EACCES;
2024                        goto restore;
2025                }
2026
2027                if (btrfs_super_log_root(fs_info->super_copy) != 0) {
2028                        btrfs_warn(fs_info,
2029                "mount required to replay tree-log, cannot remount read-write");
2030                        ret = -EINVAL;
2031                        goto restore;
2032                }
2033
2034                /*
2035                 * NOTE: when remounting with a change that does writes, don't
2036                 * put it anywhere above this point, as we are not sure to be
2037                 * safe to write until we pass the above checks.
2038                 */
2039                ret = btrfs_start_pre_rw_mount(fs_info);
2040                if (ret)
2041                        goto restore;
2042
2043                btrfs_clear_sb_rdonly(sb);
2044
2045                set_bit(BTRFS_FS_OPEN, &fs_info->flags);
2046        }
2047out:
2048        /*
2049         * We need to set SB_I_VERSION here otherwise it'll get cleared by VFS,
2050         * since the absence of the flag means it can be toggled off by remount.
2051         */
2052        *flags |= SB_I_VERSION;
2053
2054        wake_up_process(fs_info->transaction_kthread);
2055        btrfs_remount_cleanup(fs_info, old_opts);
2056        btrfs_clear_oneshot_options(fs_info);
2057        clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
2058
2059        return 0;
2060
2061restore:
2062        /* We've hit an error - don't reset SB_RDONLY */
2063        if (sb_rdonly(sb))
2064                old_flags |= SB_RDONLY;
2065        if (!(old_flags & SB_RDONLY))
2066                clear_bit(BTRFS_FS_STATE_RO, &fs_info->fs_state);
2067        sb->s_flags = old_flags;
2068        fs_info->mount_opt = old_opts;
2069        fs_info->compress_type = old_compress_type;
2070        fs_info->max_inline = old_max_inline;
2071        btrfs_resize_thread_pool(fs_info,
2072                old_thread_pool_size, fs_info->thread_pool_size);
2073        fs_info->metadata_ratio = old_metadata_ratio;
2074        btrfs_remount_cleanup(fs_info, old_opts);
2075        clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
2076
2077        return ret;
2078}
2079
2080/* Used to sort the devices by max_avail(descending sort) */
2081static int btrfs_cmp_device_free_bytes(const void *a, const void *b)
2082{
2083        const struct btrfs_device_info *dev_info1 = a;
2084        const struct btrfs_device_info *dev_info2 = b;
2085
2086        if (dev_info1->max_avail > dev_info2->max_avail)
2087                return -1;
2088        else if (dev_info1->max_avail < dev_info2->max_avail)
2089                return 1;
2090        return 0;
2091}
2092
2093/*
2094 * sort the devices by max_avail, in which max free extent size of each device
2095 * is stored.(Descending Sort)
2096 */
2097static inline void btrfs_descending_sort_devices(
2098                                        struct btrfs_device_info *devices,
2099                                        size_t nr_devices)
2100{
2101        sort(devices, nr_devices, sizeof(struct btrfs_device_info),
2102             btrfs_cmp_device_free_bytes, NULL);
2103}
2104
2105/*
2106 * The helper to calc the free space on the devices that can be used to store
2107 * file data.
2108 */
2109static inline int btrfs_calc_avail_data_space(struct btrfs_fs_info *fs_info,
2110                                              u64 *free_bytes)
2111{
2112        struct btrfs_device_info *devices_info;
2113        struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
2114        struct btrfs_device *device;
2115        u64 type;
2116        u64 avail_space;
2117        u64 min_stripe_size;
2118        int num_stripes = 1;
2119        int i = 0, nr_devices;
2120        const struct btrfs_raid_attr *rattr;
2121
2122        /*
2123         * We aren't under the device list lock, so this is racy-ish, but good
2124         * enough for our purposes.
2125         */
2126        nr_devices = fs_info->fs_devices->open_devices;
2127        if (!nr_devices) {
2128                smp_mb();
2129                nr_devices = fs_info->fs_devices->open_devices;
2130                ASSERT(nr_devices);
2131                if (!nr_devices) {
2132                        *free_bytes = 0;
2133                        return 0;
2134                }
2135        }
2136
2137        devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
2138                               GFP_KERNEL);
2139        if (!devices_info)
2140                return -ENOMEM;
2141
2142        /* calc min stripe number for data space allocation */
2143        type = btrfs_data_alloc_profile(fs_info);
2144        rattr = &btrfs_raid_array[btrfs_bg_flags_to_raid_index(type)];
2145
2146        if (type & BTRFS_BLOCK_GROUP_RAID0)
2147                num_stripes = nr_devices;
2148        else if (type & BTRFS_BLOCK_GROUP_RAID1)
2149                num_stripes = 2;
2150        else if (type & BTRFS_BLOCK_GROUP_RAID1C3)
2151                num_stripes = 3;
2152        else if (type & BTRFS_BLOCK_GROUP_RAID1C4)
2153                num_stripes = 4;
2154        else if (type & BTRFS_BLOCK_GROUP_RAID10)
2155                num_stripes = 4;
2156
2157        /* Adjust for more than 1 stripe per device */
2158        min_stripe_size = rattr->dev_stripes * BTRFS_STRIPE_LEN;
2159
2160        rcu_read_lock();
2161        list_for_each_entry_rcu(device, &fs_devices->devices, dev_list) {
2162                if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA,
2163                                                &device->dev_state) ||
2164                    !device->bdev ||
2165                    test_bit(BTRFS_DEV_STATE_REPLACE_TGT, &device->dev_state))
2166                        continue;
2167
2168                if (i >= nr_devices)
2169                        break;
2170
2171                avail_space = device->total_bytes - device->bytes_used;
2172
2173                /* align with stripe_len */
2174                avail_space = rounddown(avail_space, BTRFS_STRIPE_LEN);
2175
2176                /*
2177                 * In order to avoid overwriting the superblock on the drive,
2178                 * btrfs starts at an offset of at least 1MB when doing chunk
2179                 * allocation.
2180                 *
2181                 * This ensures we have at least min_stripe_size free space
2182                 * after excluding 1MB.
2183                 */
2184                if (avail_space <= SZ_1M + min_stripe_size)
2185                        continue;
2186
2187                avail_space -= SZ_1M;
2188
2189                devices_info[i].dev = device;
2190                devices_info[i].max_avail = avail_space;
2191
2192                i++;
2193        }
2194        rcu_read_unlock();
2195
2196        nr_devices = i;
2197
2198        btrfs_descending_sort_devices(devices_info, nr_devices);
2199
2200        i = nr_devices - 1;
2201        avail_space = 0;
2202        while (nr_devices >= rattr->devs_min) {
2203                num_stripes = min(num_stripes, nr_devices);
2204
2205                if (devices_info[i].max_avail >= min_stripe_size) {
2206                        int j;
2207                        u64 alloc_size;
2208
2209                        avail_space += devices_info[i].max_avail * num_stripes;
2210                        alloc_size = devices_info[i].max_avail;
2211                        for (j = i + 1 - num_stripes; j <= i; j++)
2212                                devices_info[j].max_avail -= alloc_size;
2213                }
2214                i--;
2215                nr_devices--;
2216        }
2217
2218        kfree(devices_info);
2219        *free_bytes = avail_space;
2220        return 0;
2221}
2222
2223/*
2224 * Calculate numbers for 'df', pessimistic in case of mixed raid profiles.
2225 *
2226 * If there's a redundant raid level at DATA block groups, use the respective
2227 * multiplier to scale the sizes.
2228 *
2229 * Unused device space usage is based on simulating the chunk allocator
2230 * algorithm that respects the device sizes and order of allocations.  This is
2231 * a close approximation of the actual use but there are other factors that may
2232 * change the result (like a new metadata chunk).
2233 *
2234 * If metadata is exhausted, f_bavail will be 0.
2235 */
2236static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
2237{
2238        struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
2239        struct btrfs_super_block *disk_super = fs_info->super_copy;
2240        struct btrfs_space_info *found;
2241        u64 total_used = 0;
2242        u64 total_free_data = 0;
2243        u64 total_free_meta = 0;
2244        u32 bits = fs_info->sectorsize_bits;
2245        __be32 *fsid = (__be32 *)fs_info->fs_devices->fsid;
2246        unsigned factor = 1;
2247        struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
2248        int ret;
2249        u64 thresh = 0;
2250        int mixed = 0;
2251
2252        list_for_each_entry(found, &fs_info->space_info, list) {
2253                if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
2254                        int i;
2255
2256                        total_free_data += found->disk_total - found->disk_used;
2257                        total_free_data -=
2258                                btrfs_account_ro_block_groups_free_space(found);
2259
2260                        for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
2261                                if (!list_empty(&found->block_groups[i]))
2262                                        factor = btrfs_bg_type_to_factor(
2263                                                btrfs_raid_array[i].bg_flag);
2264                        }
2265                }
2266
2267                /*
2268                 * Metadata in mixed block goup profiles are accounted in data
2269                 */
2270                if (!mixed && found->flags & BTRFS_BLOCK_GROUP_METADATA) {
2271                        if (found->flags & BTRFS_BLOCK_GROUP_DATA)
2272                                mixed = 1;
2273                        else
2274                                total_free_meta += found->disk_total -
2275                                        found->disk_used;
2276                }
2277
2278                total_used += found->disk_used;
2279        }
2280
2281        buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor);
2282        buf->f_blocks >>= bits;
2283        buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits);
2284
2285        /* Account global block reserve as used, it's in logical size already */
2286        spin_lock(&block_rsv->lock);
2287        /* Mixed block groups accounting is not byte-accurate, avoid overflow */
2288        if (buf->f_bfree >= block_rsv->size >> bits)
2289                buf->f_bfree -= block_rsv->size >> bits;
2290        else
2291                buf->f_bfree = 0;
2292        spin_unlock(&block_rsv->lock);
2293
2294        buf->f_bavail = div_u64(total_free_data, factor);
2295        ret = btrfs_calc_avail_data_space(fs_info, &total_free_data);
2296        if (ret)
2297                return ret;
2298        buf->f_bavail += div_u64(total_free_data, factor);
2299        buf->f_bavail = buf->f_bavail >> bits;
2300
2301        /*
2302         * We calculate the remaining metadata space minus global reserve. If
2303         * this is (supposedly) smaller than zero, there's no space. But this
2304         * does not hold in practice, the exhausted state happens where's still
2305         * some positive delta. So we apply some guesswork and compare the
2306         * delta to a 4M threshold.  (Practically observed delta was ~2M.)
2307         *
2308         * We probably cannot calculate the exact threshold value because this
2309         * depends on the internal reservations requested by various
2310         * operations, so some operations that consume a few metadata will
2311         * succeed even if the Avail is zero. But this is better than the other
2312         * way around.
2313         */
2314        thresh = SZ_4M;
2315
2316        /*
2317         * We only want to claim there's no available space if we can no longer
2318         * allocate chunks for our metadata profile and our global reserve will
2319         * not fit in the free metadata space.  If we aren't ->full then we
2320         * still can allocate chunks and thus are fine using the currently
2321         * calculated f_bavail.
2322         */
2323        if (!mixed && block_rsv->space_info->full &&
2324            total_free_meta - thresh < block_rsv->size)
2325                buf->f_bavail = 0;
2326
2327        buf->f_type = BTRFS_SUPER_MAGIC;
2328        buf->f_bsize = dentry->d_sb->s_blocksize;
2329        buf->f_namelen = BTRFS_NAME_LEN;
2330
2331        /* We treat it as constant endianness (it doesn't matter _which_)
2332           because we want the fsid to come out the same whether mounted
2333           on a big-endian or little-endian host */
2334        buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
2335        buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
2336        /* Mask in the root object ID too, to disambiguate subvols */
2337        buf->f_fsid.val[0] ^=
2338                BTRFS_I(d_inode(dentry))->root->root_key.objectid >> 32;
2339        buf->f_fsid.val[1] ^=
2340                BTRFS_I(d_inode(dentry))->root->root_key.objectid;
2341
2342        return 0;
2343}
2344
2345static void btrfs_kill_super(struct super_block *sb)
2346{
2347        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2348        kill_anon_super(sb);
2349        btrfs_free_fs_info(fs_info);
2350}
2351
2352static struct file_system_type btrfs_fs_type = {
2353        .owner          = THIS_MODULE,
2354        .name           = "btrfs",
2355        .mount          = btrfs_mount,
2356        .kill_sb        = btrfs_kill_super,
2357        .fs_flags       = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA,
2358};
2359
2360static struct file_system_type btrfs_root_fs_type = {
2361        .owner          = THIS_MODULE,
2362        .name           = "btrfs",
2363        .mount          = btrfs_mount_root,
2364        .kill_sb        = btrfs_kill_super,
2365        .fs_flags       = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA | FS_ALLOW_IDMAP,
2366};
2367
2368MODULE_ALIAS_FS("btrfs");
2369
2370static int btrfs_control_open(struct inode *inode, struct file *file)
2371{
2372        /*
2373         * The control file's private_data is used to hold the
2374         * transaction when it is started and is used to keep
2375         * track of whether a transaction is already in progress.
2376         */
2377        file->private_data = NULL;
2378        return 0;
2379}
2380
2381/*
2382 * Used by /dev/btrfs-control for devices ioctls.
2383 */
2384static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
2385                                unsigned long arg)
2386{
2387        struct btrfs_ioctl_vol_args *vol;
2388        struct btrfs_device *device = NULL;
2389        int ret = -ENOTTY;
2390
2391        if (!capable(CAP_SYS_ADMIN))
2392                return -EPERM;
2393
2394        vol = memdup_user((void __user *)arg, sizeof(*vol));
2395        if (IS_ERR(vol))
2396                return PTR_ERR(vol);
2397        vol->name[BTRFS_PATH_NAME_MAX] = '\0';
2398
2399        switch (cmd) {
2400        case BTRFS_IOC_SCAN_DEV:
2401                mutex_lock(&uuid_mutex);
2402                device = btrfs_scan_one_device(vol->name, FMODE_READ,
2403                                               &btrfs_root_fs_type);
2404                ret = PTR_ERR_OR_ZERO(device);
2405                mutex_unlock(&uuid_mutex);
2406                break;
2407        case BTRFS_IOC_FORGET_DEV:
2408                ret = btrfs_forget_devices(vol->name);
2409                break;
2410        case BTRFS_IOC_DEVICES_READY:
2411                mutex_lock(&uuid_mutex);
2412                device = btrfs_scan_one_device(vol->name, FMODE_READ,
2413                                               &btrfs_root_fs_type);
2414                if (IS_ERR(device)) {
2415                        mutex_unlock(&uuid_mutex);
2416                        ret = PTR_ERR(device);
2417                        break;
2418                }
2419                ret = !(device->fs_devices->num_devices ==
2420                        device->fs_devices->total_devices);
2421                mutex_unlock(&uuid_mutex);
2422                break;
2423        case BTRFS_IOC_GET_SUPPORTED_FEATURES:
2424                ret = btrfs_ioctl_get_supported_features((void __user*)arg);
2425                break;
2426        }
2427
2428        kfree(vol);
2429        return ret;
2430}
2431
2432static int btrfs_freeze(struct super_block *sb)
2433{
2434        struct btrfs_trans_handle *trans;
2435        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2436        struct btrfs_root *root = fs_info->tree_root;
2437
2438        set_bit(BTRFS_FS_FROZEN, &fs_info->flags);
2439        /*
2440         * We don't need a barrier here, we'll wait for any transaction that
2441         * could be in progress on other threads (and do delayed iputs that
2442         * we want to avoid on a frozen filesystem), or do the commit
2443         * ourselves.
2444         */
2445        trans = btrfs_attach_transaction_barrier(root);
2446        if (IS_ERR(trans)) {
2447                /* no transaction, don't bother */
2448                if (PTR_ERR(trans) == -ENOENT)
2449                        return 0;
2450                return PTR_ERR(trans);
2451        }
2452        return btrfs_commit_transaction(trans);
2453}
2454
2455static int btrfs_unfreeze(struct super_block *sb)
2456{
2457        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2458
2459        clear_bit(BTRFS_FS_FROZEN, &fs_info->flags);
2460        return 0;
2461}
2462
2463static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
2464{
2465        struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
2466
2467        /*
2468         * There should be always a valid pointer in latest_dev, it may be stale
2469         * for a short moment in case it's being deleted but still valid until
2470         * the end of RCU grace period.
2471         */
2472        rcu_read_lock();
2473        seq_escape(m, rcu_str_deref(fs_info->fs_devices->latest_dev->name), " \t\n\\");
2474        rcu_read_unlock();
2475
2476        return 0;
2477}
2478
2479static const struct super_operations btrfs_super_ops = {
2480        .drop_inode     = btrfs_drop_inode,
2481        .evict_inode    = btrfs_evict_inode,
2482        .put_super      = btrfs_put_super,
2483        .sync_fs        = btrfs_sync_fs,
2484        .show_options   = btrfs_show_options,
2485        .show_devname   = btrfs_show_devname,
2486        .alloc_inode    = btrfs_alloc_inode,
2487        .destroy_inode  = btrfs_destroy_inode,
2488        .free_inode     = btrfs_free_inode,
2489        .statfs         = btrfs_statfs,
2490        .remount_fs     = btrfs_remount,
2491        .freeze_fs      = btrfs_freeze,
2492        .unfreeze_fs    = btrfs_unfreeze,
2493};
2494
2495static const struct file_operations btrfs_ctl_fops = {
2496        .open = btrfs_control_open,
2497        .unlocked_ioctl  = btrfs_control_ioctl,
2498        .compat_ioctl = compat_ptr_ioctl,
2499        .owner   = THIS_MODULE,
2500        .llseek = noop_llseek,
2501};
2502
2503static struct miscdevice btrfs_misc = {
2504        .minor          = BTRFS_MINOR,
2505        .name           = "btrfs-control",
2506        .fops           = &btrfs_ctl_fops
2507};
2508
2509MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
2510MODULE_ALIAS("devname:btrfs-control");
2511
2512static int __init btrfs_interface_init(void)
2513{
2514        return misc_register(&btrfs_misc);
2515}
2516
2517static __cold void btrfs_interface_exit(void)
2518{
2519        misc_deregister(&btrfs_misc);
2520}
2521
2522static void __init btrfs_print_mod_info(void)
2523{
2524        static const char options[] = ""
2525#ifdef CONFIG_BTRFS_DEBUG
2526                        ", debug=on"
2527#endif
2528#ifdef CONFIG_BTRFS_ASSERT
2529                        ", assert=on"
2530#endif
2531#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2532                        ", integrity-checker=on"
2533#endif
2534#ifdef CONFIG_BTRFS_FS_REF_VERIFY
2535                        ", ref-verify=on"
2536#endif
2537#ifdef CONFIG_BLK_DEV_ZONED
2538                        ", zoned=yes"
2539#else
2540                        ", zoned=no"
2541#endif
2542#ifdef CONFIG_FS_VERITY
2543                        ", fsverity=yes"
2544#else
2545                        ", fsverity=no"
2546#endif
2547                        ;
2548        pr_info("Btrfs loaded, crc32c=%s%s\n", crc32c_impl(), options);
2549}
2550
2551static int __init init_btrfs_fs(void)
2552{
2553        int err;
2554
2555        btrfs_props_init();
2556
2557        err = btrfs_init_sysfs();
2558        if (err)
2559                return err;
2560
2561        btrfs_init_compress();
2562
2563        err = btrfs_init_cachep();
2564        if (err)
2565                goto free_compress;
2566
2567        err = extent_io_init();
2568        if (err)
2569                goto free_cachep;
2570
2571        err = extent_state_cache_init();
2572        if (err)
2573                goto free_extent_io;
2574
2575        err = extent_map_init();
2576        if (err)
2577                goto free_extent_state_cache;
2578
2579        err = ordered_data_init();
2580        if (err)
2581                goto free_extent_map;
2582
2583        err = btrfs_delayed_inode_init();
2584        if (err)
2585                goto free_ordered_data;
2586
2587        err = btrfs_auto_defrag_init();
2588        if (err)
2589                goto free_delayed_inode;
2590
2591        err = btrfs_delayed_ref_init();
2592        if (err)
2593                goto free_auto_defrag;
2594
2595        err = btrfs_prelim_ref_init();
2596        if (err)
2597                goto free_delayed_ref;
2598
2599        err = btrfs_end_io_wq_init();
2600        if (err)
2601                goto free_prelim_ref;
2602
2603        err = btrfs_interface_init();
2604        if (err)
2605                goto free_end_io_wq;
2606
2607        btrfs_print_mod_info();
2608
2609        err = btrfs_run_sanity_tests();
2610        if (err)
2611                goto unregister_ioctl;
2612
2613        err = register_filesystem(&btrfs_fs_type);
2614        if (err)
2615                goto unregister_ioctl;
2616
2617        return 0;
2618
2619unregister_ioctl:
2620        btrfs_interface_exit();
2621free_end_io_wq:
2622        btrfs_end_io_wq_exit();
2623free_prelim_ref:
2624        btrfs_prelim_ref_exit();
2625free_delayed_ref:
2626        btrfs_delayed_ref_exit();
2627free_auto_defrag:
2628        btrfs_auto_defrag_exit();
2629free_delayed_inode:
2630        btrfs_delayed_inode_exit();
2631free_ordered_data:
2632        ordered_data_exit();
2633free_extent_map:
2634        extent_map_exit();
2635free_extent_state_cache:
2636        extent_state_cache_exit();
2637free_extent_io:
2638        extent_io_exit();
2639free_cachep:
2640        btrfs_destroy_cachep();
2641free_compress:
2642        btrfs_exit_compress();
2643        btrfs_exit_sysfs();
2644
2645        return err;
2646}
2647
2648static void __exit exit_btrfs_fs(void)
2649{
2650        btrfs_destroy_cachep();
2651        btrfs_delayed_ref_exit();
2652        btrfs_auto_defrag_exit();
2653        btrfs_delayed_inode_exit();
2654        btrfs_prelim_ref_exit();
2655        ordered_data_exit();
2656        extent_map_exit();
2657        extent_state_cache_exit();
2658        extent_io_exit();
2659        btrfs_interface_exit();
2660        btrfs_end_io_wq_exit();
2661        unregister_filesystem(&btrfs_fs_type);
2662        btrfs_exit_sysfs();
2663        btrfs_cleanup_fs_uuids();
2664        btrfs_exit_compress();
2665}
2666
2667late_initcall(init_btrfs_fs);
2668module_exit(exit_btrfs_fs)
2669
2670MODULE_LICENSE("GPL");
2671MODULE_SOFTDEP("pre: crc32c");
2672MODULE_SOFTDEP("pre: xxhash64");
2673MODULE_SOFTDEP("pre: sha256");
2674MODULE_SOFTDEP("pre: blake2b-256");
2675