linux/fs/ntfs/super.c
<<
>>
Prefs
   1/*
   2 * super.c - NTFS kernel super block handling. Part of the Linux-NTFS project.
   3 *
   4 * Copyright (c) 2001-2012 Anton Altaparmakov and Tuxera Inc.
   5 * Copyright (c) 2001,2002 Richard Russon
   6 *
   7 * This program/include file is free software; you can redistribute it and/or
   8 * modify it under the terms of the GNU General Public License as published
   9 * by the Free Software Foundation; either version 2 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program/include file is distributed in the hope that it will be
  13 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program (in the main directory of the Linux-NTFS
  19 * distribution in the file COPYING); if not, write to the Free Software
  20 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24#include <linux/stddef.h>
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/string.h>
  28#include <linux/spinlock.h>
  29#include <linux/blkdev.h>       /* For bdev_logical_block_size(). */
  30#include <linux/backing-dev.h>
  31#include <linux/buffer_head.h>
  32#include <linux/vfs.h>
  33#include <linux/moduleparam.h>
  34#include <linux/bitmap.h>
  35
  36#include "sysctl.h"
  37#include "logfile.h"
  38#include "quota.h"
  39#include "usnjrnl.h"
  40#include "dir.h"
  41#include "debug.h"
  42#include "index.h"
  43#include "inode.h"
  44#include "aops.h"
  45#include "layout.h"
  46#include "malloc.h"
  47#include "ntfs.h"
  48
  49/* Number of mounted filesystems which have compression enabled. */
  50static unsigned long ntfs_nr_compression_users;
  51
  52/* A global default upcase table and a corresponding reference count. */
  53static ntfschar *default_upcase;
  54static unsigned long ntfs_nr_upcase_users;
  55
  56/* Error constants/strings used in inode.c::ntfs_show_options(). */
  57typedef enum {
  58        /* One of these must be present, default is ON_ERRORS_CONTINUE. */
  59        ON_ERRORS_PANIC                 = 0x01,
  60        ON_ERRORS_REMOUNT_RO            = 0x02,
  61        ON_ERRORS_CONTINUE              = 0x04,
  62        /* Optional, can be combined with any of the above. */
  63        ON_ERRORS_RECOVER               = 0x10,
  64} ON_ERRORS_ACTIONS;
  65
  66const option_t on_errors_arr[] = {
  67        { ON_ERRORS_PANIC,      "panic" },
  68        { ON_ERRORS_REMOUNT_RO, "remount-ro", },
  69        { ON_ERRORS_CONTINUE,   "continue", },
  70        { ON_ERRORS_RECOVER,    "recover" },
  71        { 0,                    NULL }
  72};
  73
  74/**
  75 * simple_getbool -
  76 *
  77 * Copied from old ntfs driver (which copied from vfat driver).
  78 */
  79static int simple_getbool(char *s, bool *setval)
  80{
  81        if (s) {
  82                if (!strcmp(s, "1") || !strcmp(s, "yes") || !strcmp(s, "true"))
  83                        *setval = true;
  84                else if (!strcmp(s, "0") || !strcmp(s, "no") ||
  85                                                        !strcmp(s, "false"))
  86                        *setval = false;
  87                else
  88                        return 0;
  89        } else
  90                *setval = true;
  91        return 1;
  92}
  93
  94/**
  95 * parse_options - parse the (re)mount options
  96 * @vol:        ntfs volume
  97 * @opt:        string containing the (re)mount options
  98 *
  99 * Parse the recognized options in @opt for the ntfs volume described by @vol.
 100 */
 101static bool parse_options(ntfs_volume *vol, char *opt)
 102{
 103        char *p, *v, *ov;
 104        static char *utf8 = "utf8";
 105        int errors = 0, sloppy = 0;
 106        kuid_t uid = INVALID_UID;
 107        kgid_t gid = INVALID_GID;
 108        umode_t fmask = (umode_t)-1, dmask = (umode_t)-1;
 109        int mft_zone_multiplier = -1, on_errors = -1;
 110        int show_sys_files = -1, case_sensitive = -1, disable_sparse = -1;
 111        struct nls_table *nls_map = NULL, *old_nls;
 112
 113        /* I am lazy... (-8 */
 114#define NTFS_GETOPT_WITH_DEFAULT(option, variable, default_value)       \
 115        if (!strcmp(p, option)) {                                       \
 116                if (!v || !*v)                                          \
 117                        variable = default_value;                       \
 118                else {                                                  \
 119                        variable = simple_strtoul(ov = v, &v, 0);       \
 120                        if (*v)                                         \
 121                                goto needs_val;                         \
 122                }                                                       \
 123        }
 124#define NTFS_GETOPT(option, variable)                                   \
 125        if (!strcmp(p, option)) {                                       \
 126                if (!v || !*v)                                          \
 127                        goto needs_arg;                                 \
 128                variable = simple_strtoul(ov = v, &v, 0);               \
 129                if (*v)                                                 \
 130                        goto needs_val;                                 \
 131        }
 132#define NTFS_GETOPT_UID(option, variable)                               \
 133        if (!strcmp(p, option)) {                                       \
 134                uid_t uid_value;                                        \
 135                if (!v || !*v)                                          \
 136                        goto needs_arg;                                 \
 137                uid_value = simple_strtoul(ov = v, &v, 0);              \
 138                if (*v)                                                 \
 139                        goto needs_val;                                 \
 140                variable = make_kuid(current_user_ns(), uid_value);     \
 141                if (!uid_valid(variable))                               \
 142                        goto needs_val;                                 \
 143        }
 144#define NTFS_GETOPT_GID(option, variable)                               \
 145        if (!strcmp(p, option)) {                                       \
 146                gid_t gid_value;                                        \
 147                if (!v || !*v)                                          \
 148                        goto needs_arg;                                 \
 149                gid_value = simple_strtoul(ov = v, &v, 0);              \
 150                if (*v)                                                 \
 151                        goto needs_val;                                 \
 152                variable = make_kgid(current_user_ns(), gid_value);     \
 153                if (!gid_valid(variable))                               \
 154                        goto needs_val;                                 \
 155        }
 156#define NTFS_GETOPT_OCTAL(option, variable)                             \
 157        if (!strcmp(p, option)) {                                       \
 158                if (!v || !*v)                                          \
 159                        goto needs_arg;                                 \
 160                variable = simple_strtoul(ov = v, &v, 8);               \
 161                if (*v)                                                 \
 162                        goto needs_val;                                 \
 163        }
 164#define NTFS_GETOPT_BOOL(option, variable)                              \
 165        if (!strcmp(p, option)) {                                       \
 166                bool val;                                               \
 167                if (!simple_getbool(v, &val))                           \
 168                        goto needs_bool;                                \
 169                variable = val;                                         \
 170        }
 171#define NTFS_GETOPT_OPTIONS_ARRAY(option, variable, opt_array)          \
 172        if (!strcmp(p, option)) {                                       \
 173                int _i;                                                 \
 174                if (!v || !*v)                                          \
 175                        goto needs_arg;                                 \
 176                ov = v;                                                 \
 177                if (variable == -1)                                     \
 178                        variable = 0;                                   \
 179                for (_i = 0; opt_array[_i].str && *opt_array[_i].str; _i++) \
 180                        if (!strcmp(opt_array[_i].str, v)) {            \
 181                                variable |= opt_array[_i].val;          \
 182                                break;                                  \
 183                        }                                               \
 184                if (!opt_array[_i].str || !*opt_array[_i].str)          \
 185                        goto needs_val;                                 \
 186        }
 187        if (!opt || !*opt)
 188                goto no_mount_options;
 189        ntfs_debug("Entering with mount options string: %s", opt);
 190        while ((p = strsep(&opt, ","))) {
 191                if ((v = strchr(p, '=')))
 192                        *v++ = 0;
 193                NTFS_GETOPT_UID("uid", uid)
 194                else NTFS_GETOPT_GID("gid", gid)
 195                else NTFS_GETOPT_OCTAL("umask", fmask = dmask)
 196                else NTFS_GETOPT_OCTAL("fmask", fmask)
 197                else NTFS_GETOPT_OCTAL("dmask", dmask)
 198                else NTFS_GETOPT("mft_zone_multiplier", mft_zone_multiplier)
 199                else NTFS_GETOPT_WITH_DEFAULT("sloppy", sloppy, true)
 200                else NTFS_GETOPT_BOOL("show_sys_files", show_sys_files)
 201                else NTFS_GETOPT_BOOL("case_sensitive", case_sensitive)
 202                else NTFS_GETOPT_BOOL("disable_sparse", disable_sparse)
 203                else NTFS_GETOPT_OPTIONS_ARRAY("errors", on_errors,
 204                                on_errors_arr)
 205                else if (!strcmp(p, "posix") || !strcmp(p, "show_inodes"))
 206                        ntfs_warning(vol->sb, "Ignoring obsolete option %s.",
 207                                        p);
 208                else if (!strcmp(p, "nls") || !strcmp(p, "iocharset")) {
 209                        if (!strcmp(p, "iocharset"))
 210                                ntfs_warning(vol->sb, "Option iocharset is "
 211                                                "deprecated. Please use "
 212                                                "option nls=<charsetname> in "
 213                                                "the future.");
 214                        if (!v || !*v)
 215                                goto needs_arg;
 216use_utf8:
 217                        old_nls = nls_map;
 218                        nls_map = load_nls(v);
 219                        if (!nls_map) {
 220                                if (!old_nls) {
 221                                        ntfs_error(vol->sb, "NLS character set "
 222                                                        "%s not found.", v);
 223                                        return false;
 224                                }
 225                                ntfs_error(vol->sb, "NLS character set %s not "
 226                                                "found. Using previous one %s.",
 227                                                v, old_nls->charset);
 228                                nls_map = old_nls;
 229                        } else /* nls_map */ {
 230                                unload_nls(old_nls);
 231                        }
 232                } else if (!strcmp(p, "utf8")) {
 233                        bool val = false;
 234                        ntfs_warning(vol->sb, "Option utf8 is no longer "
 235                                   "supported, using option nls=utf8. Please "
 236                                   "use option nls=utf8 in the future and "
 237                                   "make sure utf8 is compiled either as a "
 238                                   "module or into the kernel.");
 239                        if (!v || !*v)
 240                                val = true;
 241                        else if (!simple_getbool(v, &val))
 242                                goto needs_bool;
 243                        if (val) {
 244                                v = utf8;
 245                                goto use_utf8;
 246                        }
 247                } else {
 248                        ntfs_error(vol->sb, "Unrecognized mount option %s.", p);
 249                        if (errors < INT_MAX)
 250                                errors++;
 251                }
 252#undef NTFS_GETOPT_OPTIONS_ARRAY
 253#undef NTFS_GETOPT_BOOL
 254#undef NTFS_GETOPT
 255#undef NTFS_GETOPT_WITH_DEFAULT
 256        }
 257no_mount_options:
 258        if (errors && !sloppy)
 259                return false;
 260        if (sloppy)
 261                ntfs_warning(vol->sb, "Sloppy option given. Ignoring "
 262                                "unrecognized mount option(s) and continuing.");
 263        /* Keep this first! */
 264        if (on_errors != -1) {
 265                if (!on_errors) {
 266                        ntfs_error(vol->sb, "Invalid errors option argument "
 267                                        "or bug in options parser.");
 268                        return false;
 269                }
 270        }
 271        if (nls_map) {
 272                if (vol->nls_map && vol->nls_map != nls_map) {
 273                        ntfs_error(vol->sb, "Cannot change NLS character set "
 274                                        "on remount.");
 275                        return false;
 276                } /* else (!vol->nls_map) */
 277                ntfs_debug("Using NLS character set %s.", nls_map->charset);
 278                vol->nls_map = nls_map;
 279        } else /* (!nls_map) */ {
 280                if (!vol->nls_map) {
 281                        vol->nls_map = load_nls_default();
 282                        if (!vol->nls_map) {
 283                                ntfs_error(vol->sb, "Failed to load default "
 284                                                "NLS character set.");
 285                                return false;
 286                        }
 287                        ntfs_debug("Using default NLS character set (%s).",
 288                                        vol->nls_map->charset);
 289                }
 290        }
 291        if (mft_zone_multiplier != -1) {
 292                if (vol->mft_zone_multiplier && vol->mft_zone_multiplier !=
 293                                mft_zone_multiplier) {
 294                        ntfs_error(vol->sb, "Cannot change mft_zone_multiplier "
 295                                        "on remount.");
 296                        return false;
 297                }
 298                if (mft_zone_multiplier < 1 || mft_zone_multiplier > 4) {
 299                        ntfs_error(vol->sb, "Invalid mft_zone_multiplier. "
 300                                        "Using default value, i.e. 1.");
 301                        mft_zone_multiplier = 1;
 302                }
 303                vol->mft_zone_multiplier = mft_zone_multiplier;
 304        }
 305        if (!vol->mft_zone_multiplier)
 306                vol->mft_zone_multiplier = 1;
 307        if (on_errors != -1)
 308                vol->on_errors = on_errors;
 309        if (!vol->on_errors || vol->on_errors == ON_ERRORS_RECOVER)
 310                vol->on_errors |= ON_ERRORS_CONTINUE;
 311        if (uid_valid(uid))
 312                vol->uid = uid;
 313        if (gid_valid(gid))
 314                vol->gid = gid;
 315        if (fmask != (umode_t)-1)
 316                vol->fmask = fmask;
 317        if (dmask != (umode_t)-1)
 318                vol->dmask = dmask;
 319        if (show_sys_files != -1) {
 320                if (show_sys_files)
 321                        NVolSetShowSystemFiles(vol);
 322                else
 323                        NVolClearShowSystemFiles(vol);
 324        }
 325        if (case_sensitive != -1) {
 326                if (case_sensitive)
 327                        NVolSetCaseSensitive(vol);
 328                else
 329                        NVolClearCaseSensitive(vol);
 330        }
 331        if (disable_sparse != -1) {
 332                if (disable_sparse)
 333                        NVolClearSparseEnabled(vol);
 334                else {
 335                        if (!NVolSparseEnabled(vol) &&
 336                                        vol->major_ver && vol->major_ver < 3)
 337                                ntfs_warning(vol->sb, "Not enabling sparse "
 338                                                "support due to NTFS volume "
 339                                                "version %i.%i (need at least "
 340                                                "version 3.0).", vol->major_ver,
 341                                                vol->minor_ver);
 342                        else
 343                                NVolSetSparseEnabled(vol);
 344                }
 345        }
 346        return true;
 347needs_arg:
 348        ntfs_error(vol->sb, "The %s option requires an argument.", p);
 349        return false;
 350needs_bool:
 351        ntfs_error(vol->sb, "The %s option requires a boolean argument.", p);
 352        return false;
 353needs_val:
 354        ntfs_error(vol->sb, "Invalid %s option argument: %s", p, ov);
 355        return false;
 356}
 357
 358#ifdef NTFS_RW
 359
 360/**
 361 * ntfs_write_volume_flags - write new flags to the volume information flags
 362 * @vol:        ntfs volume on which to modify the flags
 363 * @flags:      new flags value for the volume information flags
 364 *
 365 * Internal function.  You probably want to use ntfs_{set,clear}_volume_flags()
 366 * instead (see below).
 367 *
 368 * Replace the volume information flags on the volume @vol with the value
 369 * supplied in @flags.  Note, this overwrites the volume information flags, so
 370 * make sure to combine the flags you want to modify with the old flags and use
 371 * the result when calling ntfs_write_volume_flags().
 372 *
 373 * Return 0 on success and -errno on error.
 374 */
 375static int ntfs_write_volume_flags(ntfs_volume *vol, const VOLUME_FLAGS flags)
 376{
 377        ntfs_inode *ni = NTFS_I(vol->vol_ino);
 378        MFT_RECORD *m;
 379        VOLUME_INFORMATION *vi;
 380        ntfs_attr_search_ctx *ctx;
 381        int err;
 382
 383        ntfs_debug("Entering, old flags = 0x%x, new flags = 0x%x.",
 384                        le16_to_cpu(vol->vol_flags), le16_to_cpu(flags));
 385        if (vol->vol_flags == flags)
 386                goto done;
 387        BUG_ON(!ni);
 388        m = map_mft_record(ni);
 389        if (IS_ERR(m)) {
 390                err = PTR_ERR(m);
 391                goto err_out;
 392        }
 393        ctx = ntfs_attr_get_search_ctx(ni, m);
 394        if (!ctx) {
 395                err = -ENOMEM;
 396                goto put_unm_err_out;
 397        }
 398        err = ntfs_attr_lookup(AT_VOLUME_INFORMATION, NULL, 0, 0, 0, NULL, 0,
 399                        ctx);
 400        if (err)
 401                goto put_unm_err_out;
 402        vi = (VOLUME_INFORMATION*)((u8*)ctx->attr +
 403                        le16_to_cpu(ctx->attr->data.resident.value_offset));
 404        vol->vol_flags = vi->flags = flags;
 405        flush_dcache_mft_record_page(ctx->ntfs_ino);
 406        mark_mft_record_dirty(ctx->ntfs_ino);
 407        ntfs_attr_put_search_ctx(ctx);
 408        unmap_mft_record(ni);
 409done:
 410        ntfs_debug("Done.");
 411        return 0;
 412put_unm_err_out:
 413        if (ctx)
 414                ntfs_attr_put_search_ctx(ctx);
 415        unmap_mft_record(ni);
 416err_out:
 417        ntfs_error(vol->sb, "Failed with error code %i.", -err);
 418        return err;
 419}
 420
 421/**
 422 * ntfs_set_volume_flags - set bits in the volume information flags
 423 * @vol:        ntfs volume on which to modify the flags
 424 * @flags:      flags to set on the volume
 425 *
 426 * Set the bits in @flags in the volume information flags on the volume @vol.
 427 *
 428 * Return 0 on success and -errno on error.
 429 */
 430static inline int ntfs_set_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
 431{
 432        flags &= VOLUME_FLAGS_MASK;
 433        return ntfs_write_volume_flags(vol, vol->vol_flags | flags);
 434}
 435
 436/**
 437 * ntfs_clear_volume_flags - clear bits in the volume information flags
 438 * @vol:        ntfs volume on which to modify the flags
 439 * @flags:      flags to clear on the volume
 440 *
 441 * Clear the bits in @flags in the volume information flags on the volume @vol.
 442 *
 443 * Return 0 on success and -errno on error.
 444 */
 445static inline int ntfs_clear_volume_flags(ntfs_volume *vol, VOLUME_FLAGS flags)
 446{
 447        flags &= VOLUME_FLAGS_MASK;
 448        flags = vol->vol_flags & cpu_to_le16(~le16_to_cpu(flags));
 449        return ntfs_write_volume_flags(vol, flags);
 450}
 451
 452#endif /* NTFS_RW */
 453
 454/**
 455 * ntfs_remount - change the mount options of a mounted ntfs filesystem
 456 * @sb:         superblock of mounted ntfs filesystem
 457 * @flags:      remount flags
 458 * @opt:        remount options string
 459 *
 460 * Change the mount options of an already mounted ntfs filesystem.
 461 *
 462 * NOTE:  The VFS sets the @sb->s_flags remount flags to @flags after
 463 * ntfs_remount() returns successfully (i.e. returns 0).  Otherwise,
 464 * @sb->s_flags are not changed.
 465 */
 466static int ntfs_remount(struct super_block *sb, int *flags, char *opt)
 467{
 468        ntfs_volume *vol = NTFS_SB(sb);
 469
 470        ntfs_debug("Entering with remount options string: %s", opt);
 471
 472        sync_filesystem(sb);
 473
 474#ifndef NTFS_RW
 475        /* For read-only compiled driver, enforce read-only flag. */
 476        *flags |= MS_RDONLY;
 477#else /* NTFS_RW */
 478        /*
 479         * For the read-write compiled driver, if we are remounting read-write,
 480         * make sure there are no volume errors and that no unsupported volume
 481         * flags are set.  Also, empty the logfile journal as it would become
 482         * stale as soon as something is written to the volume and mark the
 483         * volume dirty so that chkdsk is run if the volume is not umounted
 484         * cleanly.  Finally, mark the quotas out of date so Windows rescans
 485         * the volume on boot and updates them.
 486         *
 487         * When remounting read-only, mark the volume clean if no volume errors
 488         * have occurred.
 489         */
 490        if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {
 491                static const char *es = ".  Cannot remount read-write.";
 492
 493                /* Remounting read-write. */
 494                if (NVolErrors(vol)) {
 495                        ntfs_error(sb, "Volume has errors and is read-only%s",
 496                                        es);
 497                        return -EROFS;
 498                }
 499                if (vol->vol_flags & VOLUME_IS_DIRTY) {
 500                        ntfs_error(sb, "Volume is dirty and read-only%s", es);
 501                        return -EROFS;
 502                }
 503                if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
 504                        ntfs_error(sb, "Volume has been modified by chkdsk "
 505                                        "and is read-only%s", es);
 506                        return -EROFS;
 507                }
 508                if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
 509                        ntfs_error(sb, "Volume has unsupported flags set "
 510                                        "(0x%x) and is read-only%s",
 511                                        (unsigned)le16_to_cpu(vol->vol_flags),
 512                                        es);
 513                        return -EROFS;
 514                }
 515                if (ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
 516                        ntfs_error(sb, "Failed to set dirty bit in volume "
 517                                        "information flags%s", es);
 518                        return -EROFS;
 519                }
 520#if 0
 521                // TODO: Enable this code once we start modifying anything that
 522                //       is different between NTFS 1.2 and 3.x...
 523                /* Set NT4 compatibility flag on newer NTFS version volumes. */
 524                if ((vol->major_ver > 1)) {
 525                        if (ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
 526                                ntfs_error(sb, "Failed to set NT4 "
 527                                                "compatibility flag%s", es);
 528                                NVolSetErrors(vol);
 529                                return -EROFS;
 530                        }
 531                }
 532#endif
 533                if (!ntfs_empty_logfile(vol->logfile_ino)) {
 534                        ntfs_error(sb, "Failed to empty journal $LogFile%s",
 535                                        es);
 536                        NVolSetErrors(vol);
 537                        return -EROFS;
 538                }
 539                if (!ntfs_mark_quotas_out_of_date(vol)) {
 540                        ntfs_error(sb, "Failed to mark quotas out of date%s",
 541                                        es);
 542                        NVolSetErrors(vol);
 543                        return -EROFS;
 544                }
 545                if (!ntfs_stamp_usnjrnl(vol)) {
 546                        ntfs_error(sb, "Failed to stamp transation log "
 547                                        "($UsnJrnl)%s", es);
 548                        NVolSetErrors(vol);
 549                        return -EROFS;
 550                }
 551        } else if (!(sb->s_flags & MS_RDONLY) && (*flags & MS_RDONLY)) {
 552                /* Remounting read-only. */
 553                if (!NVolErrors(vol)) {
 554                        if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
 555                                ntfs_warning(sb, "Failed to clear dirty bit "
 556                                                "in volume information "
 557                                                "flags.  Run chkdsk.");
 558                }
 559        }
 560#endif /* NTFS_RW */
 561
 562        // TODO: Deal with *flags.
 563
 564        if (!parse_options(vol, opt))
 565                return -EINVAL;
 566
 567        ntfs_debug("Done.");
 568        return 0;
 569}
 570
 571/**
 572 * is_boot_sector_ntfs - check whether a boot sector is a valid NTFS boot sector
 573 * @sb:         Super block of the device to which @b belongs.
 574 * @b:          Boot sector of device @sb to check.
 575 * @silent:     If 'true', all output will be silenced.
 576 *
 577 * is_boot_sector_ntfs() checks whether the boot sector @b is a valid NTFS boot
 578 * sector. Returns 'true' if it is valid and 'false' if not.
 579 *
 580 * @sb is only needed for warning/error output, i.e. it can be NULL when silent
 581 * is 'true'.
 582 */
 583static bool is_boot_sector_ntfs(const struct super_block *sb,
 584                const NTFS_BOOT_SECTOR *b, const bool silent)
 585{
 586        /*
 587         * Check that checksum == sum of u32 values from b to the checksum
 588         * field.  If checksum is zero, no checking is done.  We will work when
 589         * the checksum test fails, since some utilities update the boot sector
 590         * ignoring the checksum which leaves the checksum out-of-date.  We
 591         * report a warning if this is the case.
 592         */
 593        if ((void*)b < (void*)&b->checksum && b->checksum && !silent) {
 594                le32 *u;
 595                u32 i;
 596
 597                for (i = 0, u = (le32*)b; u < (le32*)(&b->checksum); ++u)
 598                        i += le32_to_cpup(u);
 599                if (le32_to_cpu(b->checksum) != i)
 600                        ntfs_warning(sb, "Invalid boot sector checksum.");
 601        }
 602        /* Check OEMidentifier is "NTFS    " */
 603        if (b->oem_id != magicNTFS)
 604                goto not_ntfs;
 605        /* Check bytes per sector value is between 256 and 4096. */
 606        if (le16_to_cpu(b->bpb.bytes_per_sector) < 0x100 ||
 607                        le16_to_cpu(b->bpb.bytes_per_sector) > 0x1000)
 608                goto not_ntfs;
 609        /* Check sectors per cluster value is valid. */
 610        switch (b->bpb.sectors_per_cluster) {
 611        case 1: case 2: case 4: case 8: case 16: case 32: case 64: case 128:
 612                break;
 613        default:
 614                goto not_ntfs;
 615        }
 616        /* Check the cluster size is not above the maximum (64kiB). */
 617        if ((u32)le16_to_cpu(b->bpb.bytes_per_sector) *
 618                        b->bpb.sectors_per_cluster > NTFS_MAX_CLUSTER_SIZE)
 619                goto not_ntfs;
 620        /* Check reserved/unused fields are really zero. */
 621        if (le16_to_cpu(b->bpb.reserved_sectors) ||
 622                        le16_to_cpu(b->bpb.root_entries) ||
 623                        le16_to_cpu(b->bpb.sectors) ||
 624                        le16_to_cpu(b->bpb.sectors_per_fat) ||
 625                        le32_to_cpu(b->bpb.large_sectors) || b->bpb.fats)
 626                goto not_ntfs;
 627        /* Check clusters per file mft record value is valid. */
 628        if ((u8)b->clusters_per_mft_record < 0xe1 ||
 629                        (u8)b->clusters_per_mft_record > 0xf7)
 630                switch (b->clusters_per_mft_record) {
 631                case 1: case 2: case 4: case 8: case 16: case 32: case 64:
 632                        break;
 633                default:
 634                        goto not_ntfs;
 635                }
 636        /* Check clusters per index block value is valid. */
 637        if ((u8)b->clusters_per_index_record < 0xe1 ||
 638                        (u8)b->clusters_per_index_record > 0xf7)
 639                switch (b->clusters_per_index_record) {
 640                case 1: case 2: case 4: case 8: case 16: case 32: case 64:
 641                        break;
 642                default:
 643                        goto not_ntfs;
 644                }
 645        /*
 646         * Check for valid end of sector marker. We will work without it, but
 647         * many BIOSes will refuse to boot from a bootsector if the magic is
 648         * incorrect, so we emit a warning.
 649         */
 650        if (!silent && b->end_of_sector_marker != cpu_to_le16(0xaa55))
 651                ntfs_warning(sb, "Invalid end of sector marker.");
 652        return true;
 653not_ntfs:
 654        return false;
 655}
 656
 657/**
 658 * read_ntfs_boot_sector - read the NTFS boot sector of a device
 659 * @sb:         super block of device to read the boot sector from
 660 * @silent:     if true, suppress all output
 661 *
 662 * Reads the boot sector from the device and validates it. If that fails, tries
 663 * to read the backup boot sector, first from the end of the device a-la NT4 and
 664 * later and then from the middle of the device a-la NT3.51 and before.
 665 *
 666 * If a valid boot sector is found but it is not the primary boot sector, we
 667 * repair the primary boot sector silently (unless the device is read-only or
 668 * the primary boot sector is not accessible).
 669 *
 670 * NOTE: To call this function, @sb must have the fields s_dev, the ntfs super
 671 * block (u.ntfs_sb), nr_blocks and the device flags (s_flags) initialized
 672 * to their respective values.
 673 *
 674 * Return the unlocked buffer head containing the boot sector or NULL on error.
 675 */
 676static struct buffer_head *read_ntfs_boot_sector(struct super_block *sb,
 677                const int silent)
 678{
 679        const char *read_err_str = "Unable to read %s boot sector.";
 680        struct buffer_head *bh_primary, *bh_backup;
 681        sector_t nr_blocks = NTFS_SB(sb)->nr_blocks;
 682
 683        /* Try to read primary boot sector. */
 684        if ((bh_primary = sb_bread(sb, 0))) {
 685                if (is_boot_sector_ntfs(sb, (NTFS_BOOT_SECTOR*)
 686                                bh_primary->b_data, silent))
 687                        return bh_primary;
 688                if (!silent)
 689                        ntfs_error(sb, "Primary boot sector is invalid.");
 690        } else if (!silent)
 691                ntfs_error(sb, read_err_str, "primary");
 692        if (!(NTFS_SB(sb)->on_errors & ON_ERRORS_RECOVER)) {
 693                if (bh_primary)
 694                        brelse(bh_primary);
 695                if (!silent)
 696                        ntfs_error(sb, "Mount option errors=recover not used. "
 697                                        "Aborting without trying to recover.");
 698                return NULL;
 699        }
 700        /* Try to read NT4+ backup boot sector. */
 701        if ((bh_backup = sb_bread(sb, nr_blocks - 1))) {
 702                if (is_boot_sector_ntfs(sb, (NTFS_BOOT_SECTOR*)
 703                                bh_backup->b_data, silent))
 704                        goto hotfix_primary_boot_sector;
 705                brelse(bh_backup);
 706        } else if (!silent)
 707                ntfs_error(sb, read_err_str, "backup");
 708        /* Try to read NT3.51- backup boot sector. */
 709        if ((bh_backup = sb_bread(sb, nr_blocks >> 1))) {
 710                if (is_boot_sector_ntfs(sb, (NTFS_BOOT_SECTOR*)
 711                                bh_backup->b_data, silent))
 712                        goto hotfix_primary_boot_sector;
 713                if (!silent)
 714                        ntfs_error(sb, "Could not find a valid backup boot "
 715                                        "sector.");
 716                brelse(bh_backup);
 717        } else if (!silent)
 718                ntfs_error(sb, read_err_str, "backup");
 719        /* We failed. Cleanup and return. */
 720        if (bh_primary)
 721                brelse(bh_primary);
 722        return NULL;
 723hotfix_primary_boot_sector:
 724        if (bh_primary) {
 725                /*
 726                 * If we managed to read sector zero and the volume is not
 727                 * read-only, copy the found, valid backup boot sector to the
 728                 * primary boot sector.  Note we only copy the actual boot
 729                 * sector structure, not the actual whole device sector as that
 730                 * may be bigger and would potentially damage the $Boot system
 731                 * file (FIXME: Would be nice to know if the backup boot sector
 732                 * on a large sector device contains the whole boot loader or
 733                 * just the first 512 bytes).
 734                 */
 735                if (!(sb->s_flags & MS_RDONLY)) {
 736                        ntfs_warning(sb, "Hot-fix: Recovering invalid primary "
 737                                        "boot sector from backup copy.");
 738                        memcpy(bh_primary->b_data, bh_backup->b_data,
 739                                        NTFS_BLOCK_SIZE);
 740                        mark_buffer_dirty(bh_primary);
 741                        sync_dirty_buffer(bh_primary);
 742                        if (buffer_uptodate(bh_primary)) {
 743                                brelse(bh_backup);
 744                                return bh_primary;
 745                        }
 746                        ntfs_error(sb, "Hot-fix: Device write error while "
 747                                        "recovering primary boot sector.");
 748                } else {
 749                        ntfs_warning(sb, "Hot-fix: Recovery of primary boot "
 750                                        "sector failed: Read-only mount.");
 751                }
 752                brelse(bh_primary);
 753        }
 754        ntfs_warning(sb, "Using backup boot sector.");
 755        return bh_backup;
 756}
 757
 758/**
 759 * parse_ntfs_boot_sector - parse the boot sector and store the data in @vol
 760 * @vol:        volume structure to initialise with data from boot sector
 761 * @b:          boot sector to parse
 762 *
 763 * Parse the ntfs boot sector @b and store all imporant information therein in
 764 * the ntfs super block @vol.  Return 'true' on success and 'false' on error.
 765 */
 766static bool parse_ntfs_boot_sector(ntfs_volume *vol, const NTFS_BOOT_SECTOR *b)
 767{
 768        unsigned int sectors_per_cluster_bits, nr_hidden_sects;
 769        int clusters_per_mft_record, clusters_per_index_record;
 770        s64 ll;
 771
 772        vol->sector_size = le16_to_cpu(b->bpb.bytes_per_sector);
 773        vol->sector_size_bits = ffs(vol->sector_size) - 1;
 774        ntfs_debug("vol->sector_size = %i (0x%x)", vol->sector_size,
 775                        vol->sector_size);
 776        ntfs_debug("vol->sector_size_bits = %i (0x%x)", vol->sector_size_bits,
 777                        vol->sector_size_bits);
 778        if (vol->sector_size < vol->sb->s_blocksize) {
 779                ntfs_error(vol->sb, "Sector size (%i) is smaller than the "
 780                                "device block size (%lu).  This is not "
 781                                "supported.  Sorry.", vol->sector_size,
 782                                vol->sb->s_blocksize);
 783                return false;
 784        }
 785        ntfs_debug("sectors_per_cluster = 0x%x", b->bpb.sectors_per_cluster);
 786        sectors_per_cluster_bits = ffs(b->bpb.sectors_per_cluster) - 1;
 787        ntfs_debug("sectors_per_cluster_bits = 0x%x",
 788                        sectors_per_cluster_bits);
 789        nr_hidden_sects = le32_to_cpu(b->bpb.hidden_sectors);
 790        ntfs_debug("number of hidden sectors = 0x%x", nr_hidden_sects);
 791        vol->cluster_size = vol->sector_size << sectors_per_cluster_bits;
 792        vol->cluster_size_mask = vol->cluster_size - 1;
 793        vol->cluster_size_bits = ffs(vol->cluster_size) - 1;
 794        ntfs_debug("vol->cluster_size = %i (0x%x)", vol->cluster_size,
 795                        vol->cluster_size);
 796        ntfs_debug("vol->cluster_size_mask = 0x%x", vol->cluster_size_mask);
 797        ntfs_debug("vol->cluster_size_bits = %i", vol->cluster_size_bits);
 798        if (vol->cluster_size < vol->sector_size) {
 799                ntfs_error(vol->sb, "Cluster size (%i) is smaller than the "
 800                                "sector size (%i).  This is not supported.  "
 801                                "Sorry.", vol->cluster_size, vol->sector_size);
 802                return false;
 803        }
 804        clusters_per_mft_record = b->clusters_per_mft_record;
 805        ntfs_debug("clusters_per_mft_record = %i (0x%x)",
 806                        clusters_per_mft_record, clusters_per_mft_record);
 807        if (clusters_per_mft_record > 0)
 808                vol->mft_record_size = vol->cluster_size <<
 809                                (ffs(clusters_per_mft_record) - 1);
 810        else
 811                /*
 812                 * When mft_record_size < cluster_size, clusters_per_mft_record
 813                 * = -log2(mft_record_size) bytes. mft_record_size normaly is
 814                 * 1024 bytes, which is encoded as 0xF6 (-10 in decimal).
 815                 */
 816                vol->mft_record_size = 1 << -clusters_per_mft_record;
 817        vol->mft_record_size_mask = vol->mft_record_size - 1;
 818        vol->mft_record_size_bits = ffs(vol->mft_record_size) - 1;
 819        ntfs_debug("vol->mft_record_size = %i (0x%x)", vol->mft_record_size,
 820                        vol->mft_record_size);
 821        ntfs_debug("vol->mft_record_size_mask = 0x%x",
 822                        vol->mft_record_size_mask);
 823        ntfs_debug("vol->mft_record_size_bits = %i (0x%x)",
 824                        vol->mft_record_size_bits, vol->mft_record_size_bits);
 825        /*
 826         * We cannot support mft record sizes above the PAGE_CACHE_SIZE since
 827         * we store $MFT/$DATA, the table of mft records in the page cache.
 828         */
 829        if (vol->mft_record_size > PAGE_CACHE_SIZE) {
 830                ntfs_error(vol->sb, "Mft record size (%i) exceeds the "
 831                                "PAGE_CACHE_SIZE on your system (%lu).  "
 832                                "This is not supported.  Sorry.",
 833                                vol->mft_record_size, PAGE_CACHE_SIZE);
 834                return false;
 835        }
 836        /* We cannot support mft record sizes below the sector size. */
 837        if (vol->mft_record_size < vol->sector_size) {
 838                ntfs_error(vol->sb, "Mft record size (%i) is smaller than the "
 839                                "sector size (%i).  This is not supported.  "
 840                                "Sorry.", vol->mft_record_size,
 841                                vol->sector_size);
 842                return false;
 843        }
 844        clusters_per_index_record = b->clusters_per_index_record;
 845        ntfs_debug("clusters_per_index_record = %i (0x%x)",
 846                        clusters_per_index_record, clusters_per_index_record);
 847        if (clusters_per_index_record > 0)
 848                vol->index_record_size = vol->cluster_size <<
 849                                (ffs(clusters_per_index_record) - 1);
 850        else
 851                /*
 852                 * When index_record_size < cluster_size,
 853                 * clusters_per_index_record = -log2(index_record_size) bytes.
 854                 * index_record_size normaly equals 4096 bytes, which is
 855                 * encoded as 0xF4 (-12 in decimal).
 856                 */
 857                vol->index_record_size = 1 << -clusters_per_index_record;
 858        vol->index_record_size_mask = vol->index_record_size - 1;
 859        vol->index_record_size_bits = ffs(vol->index_record_size) - 1;
 860        ntfs_debug("vol->index_record_size = %i (0x%x)",
 861                        vol->index_record_size, vol->index_record_size);
 862        ntfs_debug("vol->index_record_size_mask = 0x%x",
 863                        vol->index_record_size_mask);
 864        ntfs_debug("vol->index_record_size_bits = %i (0x%x)",
 865                        vol->index_record_size_bits,
 866                        vol->index_record_size_bits);
 867        /* We cannot support index record sizes below the sector size. */
 868        if (vol->index_record_size < vol->sector_size) {
 869                ntfs_error(vol->sb, "Index record size (%i) is smaller than "
 870                                "the sector size (%i).  This is not "
 871                                "supported.  Sorry.", vol->index_record_size,
 872                                vol->sector_size);
 873                return false;
 874        }
 875        /*
 876         * Get the size of the volume in clusters and check for 64-bit-ness.
 877         * Windows currently only uses 32 bits to save the clusters so we do
 878         * the same as it is much faster on 32-bit CPUs.
 879         */
 880        ll = sle64_to_cpu(b->number_of_sectors) >> sectors_per_cluster_bits;
 881        if ((u64)ll >= 1ULL << 32) {
 882                ntfs_error(vol->sb, "Cannot handle 64-bit clusters.  Sorry.");
 883                return false;
 884        }
 885        vol->nr_clusters = ll;
 886        ntfs_debug("vol->nr_clusters = 0x%llx", (long long)vol->nr_clusters);
 887        /*
 888         * On an architecture where unsigned long is 32-bits, we restrict the
 889         * volume size to 2TiB (2^41). On a 64-bit architecture, the compiler
 890         * will hopefully optimize the whole check away.
 891         */
 892        if (sizeof(unsigned long) < 8) {
 893                if ((ll << vol->cluster_size_bits) >= (1ULL << 41)) {
 894                        ntfs_error(vol->sb, "Volume size (%lluTiB) is too "
 895                                        "large for this architecture.  "
 896                                        "Maximum supported is 2TiB.  Sorry.",
 897                                        (unsigned long long)ll >> (40 -
 898                                        vol->cluster_size_bits));
 899                        return false;
 900                }
 901        }
 902        ll = sle64_to_cpu(b->mft_lcn);
 903        if (ll >= vol->nr_clusters) {
 904                ntfs_error(vol->sb, "MFT LCN (%lli, 0x%llx) is beyond end of "
 905                                "volume.  Weird.", (unsigned long long)ll,
 906                                (unsigned long long)ll);
 907                return false;
 908        }
 909        vol->mft_lcn = ll;
 910        ntfs_debug("vol->mft_lcn = 0x%llx", (long long)vol->mft_lcn);
 911        ll = sle64_to_cpu(b->mftmirr_lcn);
 912        if (ll >= vol->nr_clusters) {
 913                ntfs_error(vol->sb, "MFTMirr LCN (%lli, 0x%llx) is beyond end "
 914                                "of volume.  Weird.", (unsigned long long)ll,
 915                                (unsigned long long)ll);
 916                return false;
 917        }
 918        vol->mftmirr_lcn = ll;
 919        ntfs_debug("vol->mftmirr_lcn = 0x%llx", (long long)vol->mftmirr_lcn);
 920#ifdef NTFS_RW
 921        /*
 922         * Work out the size of the mft mirror in number of mft records. If the
 923         * cluster size is less than or equal to the size taken by four mft
 924         * records, the mft mirror stores the first four mft records. If the
 925         * cluster size is bigger than the size taken by four mft records, the
 926         * mft mirror contains as many mft records as will fit into one
 927         * cluster.
 928         */
 929        if (vol->cluster_size <= (4 << vol->mft_record_size_bits))
 930                vol->mftmirr_size = 4;
 931        else
 932                vol->mftmirr_size = vol->cluster_size >>
 933                                vol->mft_record_size_bits;
 934        ntfs_debug("vol->mftmirr_size = %i", vol->mftmirr_size);
 935#endif /* NTFS_RW */
 936        vol->serial_no = le64_to_cpu(b->volume_serial_number);
 937        ntfs_debug("vol->serial_no = 0x%llx",
 938                        (unsigned long long)vol->serial_no);
 939        return true;
 940}
 941
 942/**
 943 * ntfs_setup_allocators - initialize the cluster and mft allocators
 944 * @vol:        volume structure for which to setup the allocators
 945 *
 946 * Setup the cluster (lcn) and mft allocators to the starting values.
 947 */
 948static void ntfs_setup_allocators(ntfs_volume *vol)
 949{
 950#ifdef NTFS_RW
 951        LCN mft_zone_size, mft_lcn;
 952#endif /* NTFS_RW */
 953
 954        ntfs_debug("vol->mft_zone_multiplier = 0x%x",
 955                        vol->mft_zone_multiplier);
 956#ifdef NTFS_RW
 957        /* Determine the size of the MFT zone. */
 958        mft_zone_size = vol->nr_clusters;
 959        switch (vol->mft_zone_multiplier) {  /* % of volume size in clusters */
 960        case 4:
 961                mft_zone_size >>= 1;                    /* 50%   */
 962                break;
 963        case 3:
 964                mft_zone_size = (mft_zone_size +
 965                                (mft_zone_size >> 1)) >> 2;     /* 37.5% */
 966                break;
 967        case 2:
 968                mft_zone_size >>= 2;                    /* 25%   */
 969                break;
 970        /* case 1: */
 971        default:
 972                mft_zone_size >>= 3;                    /* 12.5% */
 973                break;
 974        }
 975        /* Setup the mft zone. */
 976        vol->mft_zone_start = vol->mft_zone_pos = vol->mft_lcn;
 977        ntfs_debug("vol->mft_zone_pos = 0x%llx",
 978                        (unsigned long long)vol->mft_zone_pos);
 979        /*
 980         * Calculate the mft_lcn for an unmodified NTFS volume (see mkntfs
 981         * source) and if the actual mft_lcn is in the expected place or even
 982         * further to the front of the volume, extend the mft_zone to cover the
 983         * beginning of the volume as well.  This is in order to protect the
 984         * area reserved for the mft bitmap as well within the mft_zone itself.
 985         * On non-standard volumes we do not protect it as the overhead would
 986         * be higher than the speed increase we would get by doing it.
 987         */
 988        mft_lcn = (8192 + 2 * vol->cluster_size - 1) / vol->cluster_size;
 989        if (mft_lcn * vol->cluster_size < 16 * 1024)
 990                mft_lcn = (16 * 1024 + vol->cluster_size - 1) /
 991                                vol->cluster_size;
 992        if (vol->mft_zone_start <= mft_lcn)
 993                vol->mft_zone_start = 0;
 994        ntfs_debug("vol->mft_zone_start = 0x%llx",
 995                        (unsigned long long)vol->mft_zone_start);
 996        /*
 997         * Need to cap the mft zone on non-standard volumes so that it does
 998         * not point outside the boundaries of the volume.  We do this by
 999         * halving the zone size until we are inside the volume.
1000         */
1001        vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
1002        while (vol->mft_zone_end >= vol->nr_clusters) {
1003                mft_zone_size >>= 1;
1004                vol->mft_zone_end = vol->mft_lcn + mft_zone_size;
1005        }
1006        ntfs_debug("vol->mft_zone_end = 0x%llx",
1007                        (unsigned long long)vol->mft_zone_end);
1008        /*
1009         * Set the current position within each data zone to the start of the
1010         * respective zone.
1011         */
1012        vol->data1_zone_pos = vol->mft_zone_end;
1013        ntfs_debug("vol->data1_zone_pos = 0x%llx",
1014                        (unsigned long long)vol->data1_zone_pos);
1015        vol->data2_zone_pos = 0;
1016        ntfs_debug("vol->data2_zone_pos = 0x%llx",
1017                        (unsigned long long)vol->data2_zone_pos);
1018
1019        /* Set the mft data allocation position to mft record 24. */
1020        vol->mft_data_pos = 24;
1021        ntfs_debug("vol->mft_data_pos = 0x%llx",
1022                        (unsigned long long)vol->mft_data_pos);
1023#endif /* NTFS_RW */
1024}
1025
1026#ifdef NTFS_RW
1027
1028/**
1029 * load_and_init_mft_mirror - load and setup the mft mirror inode for a volume
1030 * @vol:        ntfs super block describing device whose mft mirror to load
1031 *
1032 * Return 'true' on success or 'false' on error.
1033 */
1034static bool load_and_init_mft_mirror(ntfs_volume *vol)
1035{
1036        struct inode *tmp_ino;
1037        ntfs_inode *tmp_ni;
1038
1039        ntfs_debug("Entering.");
1040        /* Get mft mirror inode. */
1041        tmp_ino = ntfs_iget(vol->sb, FILE_MFTMirr);
1042        if (IS_ERR(tmp_ino) || is_bad_inode(tmp_ino)) {
1043                if (!IS_ERR(tmp_ino))
1044                        iput(tmp_ino);
1045                /* Caller will display error message. */
1046                return false;
1047        }
1048        /*
1049         * Re-initialize some specifics about $MFTMirr's inode as
1050         * ntfs_read_inode() will have set up the default ones.
1051         */
1052        /* Set uid and gid to root. */
1053        tmp_ino->i_uid = GLOBAL_ROOT_UID;
1054        tmp_ino->i_gid = GLOBAL_ROOT_GID;
1055        /* Regular file.  No access for anyone. */
1056        tmp_ino->i_mode = S_IFREG;
1057        /* No VFS initiated operations allowed for $MFTMirr. */
1058        tmp_ino->i_op = &ntfs_empty_inode_ops;
1059        tmp_ino->i_fop = &ntfs_empty_file_ops;
1060        /* Put in our special address space operations. */
1061        tmp_ino->i_mapping->a_ops = &ntfs_mst_aops;
1062        tmp_ni = NTFS_I(tmp_ino);
1063        /* The $MFTMirr, like the $MFT is multi sector transfer protected. */
1064        NInoSetMstProtected(tmp_ni);
1065        NInoSetSparseDisabled(tmp_ni);
1066        /*
1067         * Set up our little cheat allowing us to reuse the async read io
1068         * completion handler for directories.
1069         */
1070        tmp_ni->itype.index.block_size = vol->mft_record_size;
1071        tmp_ni->itype.index.block_size_bits = vol->mft_record_size_bits;
1072        vol->mftmirr_ino = tmp_ino;
1073        ntfs_debug("Done.");
1074        return true;
1075}
1076
1077/**
1078 * check_mft_mirror - compare contents of the mft mirror with the mft
1079 * @vol:        ntfs super block describing device whose mft mirror to check
1080 *
1081 * Return 'true' on success or 'false' on error.
1082 *
1083 * Note, this function also results in the mft mirror runlist being completely
1084 * mapped into memory.  The mft mirror write code requires this and will BUG()
1085 * should it find an unmapped runlist element.
1086 */
1087static bool check_mft_mirror(ntfs_volume *vol)
1088{
1089        struct super_block *sb = vol->sb;
1090        ntfs_inode *mirr_ni;
1091        struct page *mft_page, *mirr_page;
1092        u8 *kmft, *kmirr;
1093        runlist_element *rl, rl2[2];
1094        pgoff_t index;
1095        int mrecs_per_page, i;
1096
1097        ntfs_debug("Entering.");
1098        /* Compare contents of $MFT and $MFTMirr. */
1099        mrecs_per_page = PAGE_CACHE_SIZE / vol->mft_record_size;
1100        BUG_ON(!mrecs_per_page);
1101        BUG_ON(!vol->mftmirr_size);
1102        mft_page = mirr_page = NULL;
1103        kmft = kmirr = NULL;
1104        index = i = 0;
1105        do {
1106                u32 bytes;
1107
1108                /* Switch pages if necessary. */
1109                if (!(i % mrecs_per_page)) {
1110                        if (index) {
1111                                ntfs_unmap_page(mft_page);
1112                                ntfs_unmap_page(mirr_page);
1113                        }
1114                        /* Get the $MFT page. */
1115                        mft_page = ntfs_map_page(vol->mft_ino->i_mapping,
1116                                        index);
1117                        if (IS_ERR(mft_page)) {
1118                                ntfs_error(sb, "Failed to read $MFT.");
1119                                return false;
1120                        }
1121                        kmft = page_address(mft_page);
1122                        /* Get the $MFTMirr page. */
1123                        mirr_page = ntfs_map_page(vol->mftmirr_ino->i_mapping,
1124                                        index);
1125                        if (IS_ERR(mirr_page)) {
1126                                ntfs_error(sb, "Failed to read $MFTMirr.");
1127                                goto mft_unmap_out;
1128                        }
1129                        kmirr = page_address(mirr_page);
1130                        ++index;
1131                }
1132                /* Do not check the record if it is not in use. */
1133                if (((MFT_RECORD*)kmft)->flags & MFT_RECORD_IN_USE) {
1134                        /* Make sure the record is ok. */
1135                        if (ntfs_is_baad_recordp((le32*)kmft)) {
1136                                ntfs_error(sb, "Incomplete multi sector "
1137                                                "transfer detected in mft "
1138                                                "record %i.", i);
1139mm_unmap_out:
1140                                ntfs_unmap_page(mirr_page);
1141mft_unmap_out:
1142                                ntfs_unmap_page(mft_page);
1143                                return false;
1144                        }
1145                }
1146                /* Do not check the mirror record if it is not in use. */
1147                if (((MFT_RECORD*)kmirr)->flags & MFT_RECORD_IN_USE) {
1148                        if (ntfs_is_baad_recordp((le32*)kmirr)) {
1149                                ntfs_error(sb, "Incomplete multi sector "
1150                                                "transfer detected in mft "
1151                                                "mirror record %i.", i);
1152                                goto mm_unmap_out;
1153                        }
1154                }
1155                /* Get the amount of data in the current record. */
1156                bytes = le32_to_cpu(((MFT_RECORD*)kmft)->bytes_in_use);
1157                if (bytes < sizeof(MFT_RECORD_OLD) ||
1158                                bytes > vol->mft_record_size ||
1159                                ntfs_is_baad_recordp((le32*)kmft)) {
1160                        bytes = le32_to_cpu(((MFT_RECORD*)kmirr)->bytes_in_use);
1161                        if (bytes < sizeof(MFT_RECORD_OLD) ||
1162                                        bytes > vol->mft_record_size ||
1163                                        ntfs_is_baad_recordp((le32*)kmirr))
1164                                bytes = vol->mft_record_size;
1165                }
1166                /* Compare the two records. */
1167                if (memcmp(kmft, kmirr, bytes)) {
1168                        ntfs_error(sb, "$MFT and $MFTMirr (record %i) do not "
1169                                        "match.  Run ntfsfix or chkdsk.", i);
1170                        goto mm_unmap_out;
1171                }
1172                kmft += vol->mft_record_size;
1173                kmirr += vol->mft_record_size;
1174        } while (++i < vol->mftmirr_size);
1175        /* Release the last pages. */
1176        ntfs_unmap_page(mft_page);
1177        ntfs_unmap_page(mirr_page);
1178
1179        /* Construct the mft mirror runlist by hand. */
1180        rl2[0].vcn = 0;
1181        rl2[0].lcn = vol->mftmirr_lcn;
1182        rl2[0].length = (vol->mftmirr_size * vol->mft_record_size +
1183                        vol->cluster_size - 1) / vol->cluster_size;
1184        rl2[1].vcn = rl2[0].length;
1185        rl2[1].lcn = LCN_ENOENT;
1186        rl2[1].length = 0;
1187        /*
1188         * Because we have just read all of the mft mirror, we know we have
1189         * mapped the full runlist for it.
1190         */
1191        mirr_ni = NTFS_I(vol->mftmirr_ino);
1192        down_read(&mirr_ni->runlist.lock);
1193        rl = mirr_ni->runlist.rl;
1194        /* Compare the two runlists.  They must be identical. */
1195        i = 0;
1196        do {
1197                if (rl2[i].vcn != rl[i].vcn || rl2[i].lcn != rl[i].lcn ||
1198                                rl2[i].length != rl[i].length) {
1199                        ntfs_error(sb, "$MFTMirr location mismatch.  "
1200                                        "Run chkdsk.");
1201                        up_read(&mirr_ni->runlist.lock);
1202                        return false;
1203                }
1204        } while (rl2[i++].length);
1205        up_read(&mirr_ni->runlist.lock);
1206        ntfs_debug("Done.");
1207        return true;
1208}
1209
1210/**
1211 * load_and_check_logfile - load and check the logfile inode for a volume
1212 * @vol:        ntfs super block describing device whose logfile to load
1213 *
1214 * Return 'true' on success or 'false' on error.
1215 */
1216static bool load_and_check_logfile(ntfs_volume *vol,
1217                RESTART_PAGE_HEADER **rp)
1218{
1219        struct inode *tmp_ino;
1220
1221        ntfs_debug("Entering.");
1222        tmp_ino = ntfs_iget(vol->sb, FILE_LogFile);
1223        if (IS_ERR(tmp_ino) || is_bad_inode(tmp_ino)) {
1224                if (!IS_ERR(tmp_ino))
1225                        iput(tmp_ino);
1226                /* Caller will display error message. */
1227                return false;
1228        }
1229        if (!ntfs_check_logfile(tmp_ino, rp)) {
1230                iput(tmp_ino);
1231                /* ntfs_check_logfile() will have displayed error output. */
1232                return false;
1233        }
1234        NInoSetSparseDisabled(NTFS_I(tmp_ino));
1235        vol->logfile_ino = tmp_ino;
1236        ntfs_debug("Done.");
1237        return true;
1238}
1239
1240#define NTFS_HIBERFIL_HEADER_SIZE       4096
1241
1242/**
1243 * check_windows_hibernation_status - check if Windows is suspended on a volume
1244 * @vol:        ntfs super block of device to check
1245 *
1246 * Check if Windows is hibernated on the ntfs volume @vol.  This is done by
1247 * looking for the file hiberfil.sys in the root directory of the volume.  If
1248 * the file is not present Windows is definitely not suspended.
1249 *
1250 * If hiberfil.sys exists and is less than 4kiB in size it means Windows is
1251 * definitely suspended (this volume is not the system volume).  Caveat:  on a
1252 * system with many volumes it is possible that the < 4kiB check is bogus but
1253 * for now this should do fine.
1254 *
1255 * If hiberfil.sys exists and is larger than 4kiB in size, we need to read the
1256 * hiberfil header (which is the first 4kiB).  If this begins with "hibr",
1257 * Windows is definitely suspended.  If it is completely full of zeroes,
1258 * Windows is definitely not hibernated.  Any other case is treated as if
1259 * Windows is suspended.  This caters for the above mentioned caveat of a
1260 * system with many volumes where no "hibr" magic would be present and there is
1261 * no zero header.
1262 *
1263 * Return 0 if Windows is not hibernated on the volume, >0 if Windows is
1264 * hibernated on the volume, and -errno on error.
1265 */
1266static int check_windows_hibernation_status(ntfs_volume *vol)
1267{
1268        MFT_REF mref;
1269        struct inode *vi;
1270        struct page *page;
1271        u32 *kaddr, *kend;
1272        ntfs_name *name = NULL;
1273        int ret = 1;
1274        static const ntfschar hiberfil[13] = { cpu_to_le16('h'),
1275                        cpu_to_le16('i'), cpu_to_le16('b'),
1276                        cpu_to_le16('e'), cpu_to_le16('r'),
1277                        cpu_to_le16('f'), cpu_to_le16('i'),
1278                        cpu_to_le16('l'), cpu_to_le16('.'),
1279                        cpu_to_le16('s'), cpu_to_le16('y'),
1280                        cpu_to_le16('s'), 0 };
1281
1282        ntfs_debug("Entering.");
1283        /*
1284         * Find the inode number for the hibernation file by looking up the
1285         * filename hiberfil.sys in the root directory.
1286         */
1287        mutex_lock(&vol->root_ino->i_mutex);
1288        mref = ntfs_lookup_inode_by_name(NTFS_I(vol->root_ino), hiberfil, 12,
1289                        &name);
1290        mutex_unlock(&vol->root_ino->i_mutex);
1291        if (IS_ERR_MREF(mref)) {
1292                ret = MREF_ERR(mref);
1293                /* If the file does not exist, Windows is not hibernated. */
1294                if (ret == -ENOENT) {
1295                        ntfs_debug("hiberfil.sys not present.  Windows is not "
1296                                        "hibernated on the volume.");
1297                        return 0;
1298                }
1299                /* A real error occurred. */
1300                ntfs_error(vol->sb, "Failed to find inode number for "
1301                                "hiberfil.sys.");
1302                return ret;
1303        }
1304        /* We do not care for the type of match that was found. */
1305        kfree(name);
1306        /* Get the inode. */
1307        vi = ntfs_iget(vol->sb, MREF(mref));
1308        if (IS_ERR(vi) || is_bad_inode(vi)) {
1309                if (!IS_ERR(vi))
1310                        iput(vi);
1311                ntfs_error(vol->sb, "Failed to load hiberfil.sys.");
1312                return IS_ERR(vi) ? PTR_ERR(vi) : -EIO;
1313        }
1314        if (unlikely(i_size_read(vi) < NTFS_HIBERFIL_HEADER_SIZE)) {
1315                ntfs_debug("hiberfil.sys is smaller than 4kiB (0x%llx).  "
1316                                "Windows is hibernated on the volume.  This "
1317                                "is not the system volume.", i_size_read(vi));
1318                goto iput_out;
1319        }
1320        page = ntfs_map_page(vi->i_mapping, 0);
1321        if (IS_ERR(page)) {
1322                ntfs_error(vol->sb, "Failed to read from hiberfil.sys.");
1323                ret = PTR_ERR(page);
1324                goto iput_out;
1325        }
1326        kaddr = (u32*)page_address(page);
1327        if (*(le32*)kaddr == cpu_to_le32(0x72626968)/*'hibr'*/) {
1328                ntfs_debug("Magic \"hibr\" found in hiberfil.sys.  Windows is "
1329                                "hibernated on the volume.  This is the "
1330                                "system volume.");
1331                goto unm_iput_out;
1332        }
1333        kend = kaddr + NTFS_HIBERFIL_HEADER_SIZE/sizeof(*kaddr);
1334        do {
1335                if (unlikely(*kaddr)) {
1336                        ntfs_debug("hiberfil.sys is larger than 4kiB "
1337                                        "(0x%llx), does not contain the "
1338                                        "\"hibr\" magic, and does not have a "
1339                                        "zero header.  Windows is hibernated "
1340                                        "on the volume.  This is not the "
1341                                        "system volume.", i_size_read(vi));
1342                        goto unm_iput_out;
1343                }
1344        } while (++kaddr < kend);
1345        ntfs_debug("hiberfil.sys contains a zero header.  Windows is not "
1346                        "hibernated on the volume.  This is the system "
1347                        "volume.");
1348        ret = 0;
1349unm_iput_out:
1350        ntfs_unmap_page(page);
1351iput_out:
1352        iput(vi);
1353        return ret;
1354}
1355
1356/**
1357 * load_and_init_quota - load and setup the quota file for a volume if present
1358 * @vol:        ntfs super block describing device whose quota file to load
1359 *
1360 * Return 'true' on success or 'false' on error.  If $Quota is not present, we
1361 * leave vol->quota_ino as NULL and return success.
1362 */
1363static bool load_and_init_quota(ntfs_volume *vol)
1364{
1365        MFT_REF mref;
1366        struct inode *tmp_ino;
1367        ntfs_name *name = NULL;
1368        static const ntfschar Quota[7] = { cpu_to_le16('$'),
1369                        cpu_to_le16('Q'), cpu_to_le16('u'),
1370                        cpu_to_le16('o'), cpu_to_le16('t'),
1371                        cpu_to_le16('a'), 0 };
1372        static ntfschar Q[3] = { cpu_to_le16('$'),
1373                        cpu_to_le16('Q'), 0 };
1374
1375        ntfs_debug("Entering.");
1376        /*
1377         * Find the inode number for the quota file by looking up the filename
1378         * $Quota in the extended system files directory $Extend.
1379         */
1380        mutex_lock(&vol->extend_ino->i_mutex);
1381        mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), Quota, 6,
1382                        &name);
1383        mutex_unlock(&vol->extend_ino->i_mutex);
1384        if (IS_ERR_MREF(mref)) {
1385                /*
1386                 * If the file does not exist, quotas are disabled and have
1387                 * never been enabled on this volume, just return success.
1388                 */
1389                if (MREF_ERR(mref) == -ENOENT) {
1390                        ntfs_debug("$Quota not present.  Volume does not have "
1391                                        "quotas enabled.");
1392                        /*
1393                         * No need to try to set quotas out of date if they are
1394                         * not enabled.
1395                         */
1396                        NVolSetQuotaOutOfDate(vol);
1397                        return true;
1398                }
1399                /* A real error occurred. */
1400                ntfs_error(vol->sb, "Failed to find inode number for $Quota.");
1401                return false;
1402        }
1403        /* We do not care for the type of match that was found. */
1404        kfree(name);
1405        /* Get the inode. */
1406        tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1407        if (IS_ERR(tmp_ino) || is_bad_inode(tmp_ino)) {
1408                if (!IS_ERR(tmp_ino))
1409                        iput(tmp_ino);
1410                ntfs_error(vol->sb, "Failed to load $Quota.");
1411                return false;
1412        }
1413        vol->quota_ino = tmp_ino;
1414        /* Get the $Q index allocation attribute. */
1415        tmp_ino = ntfs_index_iget(vol->quota_ino, Q, 2);
1416        if (IS_ERR(tmp_ino)) {
1417                ntfs_error(vol->sb, "Failed to load $Quota/$Q index.");
1418                return false;
1419        }
1420        vol->quota_q_ino = tmp_ino;
1421        ntfs_debug("Done.");
1422        return true;
1423}
1424
1425/**
1426 * load_and_init_usnjrnl - load and setup the transaction log if present
1427 * @vol:        ntfs super block describing device whose usnjrnl file to load
1428 *
1429 * Return 'true' on success or 'false' on error.
1430 *
1431 * If $UsnJrnl is not present or in the process of being disabled, we set
1432 * NVolUsnJrnlStamped() and return success.
1433 *
1434 * If the $UsnJrnl $DATA/$J attribute has a size equal to the lowest valid usn,
1435 * i.e. transaction logging has only just been enabled or the journal has been
1436 * stamped and nothing has been logged since, we also set NVolUsnJrnlStamped()
1437 * and return success.
1438 */
1439static bool load_and_init_usnjrnl(ntfs_volume *vol)
1440{
1441        MFT_REF mref;
1442        struct inode *tmp_ino;
1443        ntfs_inode *tmp_ni;
1444        struct page *page;
1445        ntfs_name *name = NULL;
1446        USN_HEADER *uh;
1447        static const ntfschar UsnJrnl[9] = { cpu_to_le16('$'),
1448                        cpu_to_le16('U'), cpu_to_le16('s'),
1449                        cpu_to_le16('n'), cpu_to_le16('J'),
1450                        cpu_to_le16('r'), cpu_to_le16('n'),
1451                        cpu_to_le16('l'), 0 };
1452        static ntfschar Max[5] = { cpu_to_le16('$'),
1453                        cpu_to_le16('M'), cpu_to_le16('a'),
1454                        cpu_to_le16('x'), 0 };
1455        static ntfschar J[3] = { cpu_to_le16('$'),
1456                        cpu_to_le16('J'), 0 };
1457
1458        ntfs_debug("Entering.");
1459        /*
1460         * Find the inode number for the transaction log file by looking up the
1461         * filename $UsnJrnl in the extended system files directory $Extend.
1462         */
1463        mutex_lock(&vol->extend_ino->i_mutex);
1464        mref = ntfs_lookup_inode_by_name(NTFS_I(vol->extend_ino), UsnJrnl, 8,
1465                        &name);
1466        mutex_unlock(&vol->extend_ino->i_mutex);
1467        if (IS_ERR_MREF(mref)) {
1468                /*
1469                 * If the file does not exist, transaction logging is disabled,
1470                 * just return success.
1471                 */
1472                if (MREF_ERR(mref) == -ENOENT) {
1473                        ntfs_debug("$UsnJrnl not present.  Volume does not "
1474                                        "have transaction logging enabled.");
1475not_enabled:
1476                        /*
1477                         * No need to try to stamp the transaction log if
1478                         * transaction logging is not enabled.
1479                         */
1480                        NVolSetUsnJrnlStamped(vol);
1481                        return true;
1482                }
1483                /* A real error occurred. */
1484                ntfs_error(vol->sb, "Failed to find inode number for "
1485                                "$UsnJrnl.");
1486                return false;
1487        }
1488        /* We do not care for the type of match that was found. */
1489        kfree(name);
1490        /* Get the inode. */
1491        tmp_ino = ntfs_iget(vol->sb, MREF(mref));
1492        if (unlikely(IS_ERR(tmp_ino) || is_bad_inode(tmp_ino))) {
1493                if (!IS_ERR(tmp_ino))
1494                        iput(tmp_ino);
1495                ntfs_error(vol->sb, "Failed to load $UsnJrnl.");
1496                return false;
1497        }
1498        vol->usnjrnl_ino = tmp_ino;
1499        /*
1500         * If the transaction log is in the process of being deleted, we can
1501         * ignore it.
1502         */
1503        if (unlikely(vol->vol_flags & VOLUME_DELETE_USN_UNDERWAY)) {
1504                ntfs_debug("$UsnJrnl in the process of being disabled.  "
1505                                "Volume does not have transaction logging "
1506                                "enabled.");
1507                goto not_enabled;
1508        }
1509        /* Get the $DATA/$Max attribute. */
1510        tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, Max, 4);
1511        if (IS_ERR(tmp_ino)) {
1512                ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$Max "
1513                                "attribute.");
1514                return false;
1515        }
1516        vol->usnjrnl_max_ino = tmp_ino;
1517        if (unlikely(i_size_read(tmp_ino) < sizeof(USN_HEADER))) {
1518                ntfs_error(vol->sb, "Found corrupt $UsnJrnl/$DATA/$Max "
1519                                "attribute (size is 0x%llx but should be at "
1520                                "least 0x%zx bytes).", i_size_read(tmp_ino),
1521                                sizeof(USN_HEADER));
1522                return false;
1523        }
1524        /* Get the $DATA/$J attribute. */
1525        tmp_ino = ntfs_attr_iget(vol->usnjrnl_ino, AT_DATA, J, 2);
1526        if (IS_ERR(tmp_ino)) {
1527                ntfs_error(vol->sb, "Failed to load $UsnJrnl/$DATA/$J "
1528                                "attribute.");
1529                return false;
1530        }
1531        vol->usnjrnl_j_ino = tmp_ino;
1532        /* Verify $J is non-resident and sparse. */
1533        tmp_ni = NTFS_I(vol->usnjrnl_j_ino);
1534        if (unlikely(!NInoNonResident(tmp_ni) || !NInoSparse(tmp_ni))) {
1535                ntfs_error(vol->sb, "$UsnJrnl/$DATA/$J attribute is resident "
1536                                "and/or not sparse.");
1537                return false;
1538        }
1539        /* Read the USN_HEADER from $DATA/$Max. */
1540        page = ntfs_map_page(vol->usnjrnl_max_ino->i_mapping, 0);
1541        if (IS_ERR(page)) {
1542                ntfs_error(vol->sb, "Failed to read from $UsnJrnl/$DATA/$Max "
1543                                "attribute.");
1544                return false;
1545        }
1546        uh = (USN_HEADER*)page_address(page);
1547        /* Sanity check the $Max. */
1548        if (unlikely(sle64_to_cpu(uh->allocation_delta) >
1549                        sle64_to_cpu(uh->maximum_size))) {
1550                ntfs_error(vol->sb, "Allocation delta (0x%llx) exceeds "
1551                                "maximum size (0x%llx).  $UsnJrnl is corrupt.",
1552                                (long long)sle64_to_cpu(uh->allocation_delta),
1553                                (long long)sle64_to_cpu(uh->maximum_size));
1554                ntfs_unmap_page(page);
1555                return false;
1556        }
1557        /*
1558         * If the transaction log has been stamped and nothing has been written
1559         * to it since, we do not need to stamp it.
1560         */
1561        if (unlikely(sle64_to_cpu(uh->lowest_valid_usn) >=
1562                        i_size_read(vol->usnjrnl_j_ino))) {
1563                if (likely(sle64_to_cpu(uh->lowest_valid_usn) ==
1564                                i_size_read(vol->usnjrnl_j_ino))) {
1565                        ntfs_unmap_page(page);
1566                        ntfs_debug("$UsnJrnl is enabled but nothing has been "
1567                                        "logged since it was last stamped.  "
1568                                        "Treating this as if the volume does "
1569                                        "not have transaction logging "
1570                                        "enabled.");
1571                        goto not_enabled;
1572                }
1573                ntfs_error(vol->sb, "$UsnJrnl has lowest valid usn (0x%llx) "
1574                                "which is out of bounds (0x%llx).  $UsnJrnl "
1575                                "is corrupt.",
1576                                (long long)sle64_to_cpu(uh->lowest_valid_usn),
1577                                i_size_read(vol->usnjrnl_j_ino));
1578                ntfs_unmap_page(page);
1579                return false;
1580        }
1581        ntfs_unmap_page(page);
1582        ntfs_debug("Done.");
1583        return true;
1584}
1585
1586/**
1587 * load_and_init_attrdef - load the attribute definitions table for a volume
1588 * @vol:        ntfs super block describing device whose attrdef to load
1589 *
1590 * Return 'true' on success or 'false' on error.
1591 */
1592static bool load_and_init_attrdef(ntfs_volume *vol)
1593{
1594        loff_t i_size;
1595        struct super_block *sb = vol->sb;
1596        struct inode *ino;
1597        struct page *page;
1598        pgoff_t index, max_index;
1599        unsigned int size;
1600
1601        ntfs_debug("Entering.");
1602        /* Read attrdef table and setup vol->attrdef and vol->attrdef_size. */
1603        ino = ntfs_iget(sb, FILE_AttrDef);
1604        if (IS_ERR(ino) || is_bad_inode(ino)) {
1605                if (!IS_ERR(ino))
1606                        iput(ino);
1607                goto failed;
1608        }
1609        NInoSetSparseDisabled(NTFS_I(ino));
1610        /* The size of FILE_AttrDef must be above 0 and fit inside 31 bits. */
1611        i_size = i_size_read(ino);
1612        if (i_size <= 0 || i_size > 0x7fffffff)
1613                goto iput_failed;
1614        vol->attrdef = (ATTR_DEF*)ntfs_malloc_nofs(i_size);
1615        if (!vol->attrdef)
1616                goto iput_failed;
1617        index = 0;
1618        max_index = i_size >> PAGE_CACHE_SHIFT;
1619        size = PAGE_CACHE_SIZE;
1620        while (index < max_index) {
1621                /* Read the attrdef table and copy it into the linear buffer. */
1622read_partial_attrdef_page:
1623                page = ntfs_map_page(ino->i_mapping, index);
1624                if (IS_ERR(page))
1625                        goto free_iput_failed;
1626                memcpy((u8*)vol->attrdef + (index++ << PAGE_CACHE_SHIFT),
1627                                page_address(page), size);
1628                ntfs_unmap_page(page);
1629        };
1630        if (size == PAGE_CACHE_SIZE) {
1631                size = i_size & ~PAGE_CACHE_MASK;
1632                if (size)
1633                        goto read_partial_attrdef_page;
1634        }
1635        vol->attrdef_size = i_size;
1636        ntfs_debug("Read %llu bytes from $AttrDef.", i_size);
1637        iput(ino);
1638        return true;
1639free_iput_failed:
1640        ntfs_free(vol->attrdef);
1641        vol->attrdef = NULL;
1642iput_failed:
1643        iput(ino);
1644failed:
1645        ntfs_error(sb, "Failed to initialize attribute definition table.");
1646        return false;
1647}
1648
1649#endif /* NTFS_RW */
1650
1651/**
1652 * load_and_init_upcase - load the upcase table for an ntfs volume
1653 * @vol:        ntfs super block describing device whose upcase to load
1654 *
1655 * Return 'true' on success or 'false' on error.
1656 */
1657static bool load_and_init_upcase(ntfs_volume *vol)
1658{
1659        loff_t i_size;
1660        struct super_block *sb = vol->sb;
1661        struct inode *ino;
1662        struct page *page;
1663        pgoff_t index, max_index;
1664        unsigned int size;
1665        int i, max;
1666
1667        ntfs_debug("Entering.");
1668        /* Read upcase table and setup vol->upcase and vol->upcase_len. */
1669        ino = ntfs_iget(sb, FILE_UpCase);
1670        if (IS_ERR(ino) || is_bad_inode(ino)) {
1671                if (!IS_ERR(ino))
1672                        iput(ino);
1673                goto upcase_failed;
1674        }
1675        /*
1676         * The upcase size must not be above 64k Unicode characters, must not
1677         * be zero and must be a multiple of sizeof(ntfschar).
1678         */
1679        i_size = i_size_read(ino);
1680        if (!i_size || i_size & (sizeof(ntfschar) - 1) ||
1681                        i_size > 64ULL * 1024 * sizeof(ntfschar))
1682                goto iput_upcase_failed;
1683        vol->upcase = (ntfschar*)ntfs_malloc_nofs(i_size);
1684        if (!vol->upcase)
1685                goto iput_upcase_failed;
1686        index = 0;
1687        max_index = i_size >> PAGE_CACHE_SHIFT;
1688        size = PAGE_CACHE_SIZE;
1689        while (index < max_index) {
1690                /* Read the upcase table and copy it into the linear buffer. */
1691read_partial_upcase_page:
1692                page = ntfs_map_page(ino->i_mapping, index);
1693                if (IS_ERR(page))
1694                        goto iput_upcase_failed;
1695                memcpy((char*)vol->upcase + (index++ << PAGE_CACHE_SHIFT),
1696                                page_address(page), size);
1697                ntfs_unmap_page(page);
1698        };
1699        if (size == PAGE_CACHE_SIZE) {
1700                size = i_size & ~PAGE_CACHE_MASK;
1701                if (size)
1702                        goto read_partial_upcase_page;
1703        }
1704        vol->upcase_len = i_size >> UCHAR_T_SIZE_BITS;
1705        ntfs_debug("Read %llu bytes from $UpCase (expected %zu bytes).",
1706                        i_size, 64 * 1024 * sizeof(ntfschar));
1707        iput(ino);
1708        mutex_lock(&ntfs_lock);
1709        if (!default_upcase) {
1710                ntfs_debug("Using volume specified $UpCase since default is "
1711                                "not present.");
1712                mutex_unlock(&ntfs_lock);
1713                return true;
1714        }
1715        max = default_upcase_len;
1716        if (max > vol->upcase_len)
1717                max = vol->upcase_len;
1718        for (i = 0; i < max; i++)
1719                if (vol->upcase[i] != default_upcase[i])
1720                        break;
1721        if (i == max) {
1722                ntfs_free(vol->upcase);
1723                vol->upcase = default_upcase;
1724                vol->upcase_len = max;
1725                ntfs_nr_upcase_users++;
1726                mutex_unlock(&ntfs_lock);
1727                ntfs_debug("Volume specified $UpCase matches default. Using "
1728                                "default.");
1729                return true;
1730        }
1731        mutex_unlock(&ntfs_lock);
1732        ntfs_debug("Using volume specified $UpCase since it does not match "
1733                        "the default.");
1734        return true;
1735iput_upcase_failed:
1736        iput(ino);
1737        ntfs_free(vol->upcase);
1738        vol->upcase = NULL;
1739upcase_failed:
1740        mutex_lock(&ntfs_lock);
1741        if (default_upcase) {
1742                vol->upcase = default_upcase;
1743                vol->upcase_len = default_upcase_len;
1744                ntfs_nr_upcase_users++;
1745                mutex_unlock(&ntfs_lock);
1746                ntfs_error(sb, "Failed to load $UpCase from the volume. Using "
1747                                "default.");
1748                return true;
1749        }
1750        mutex_unlock(&ntfs_lock);
1751        ntfs_error(sb, "Failed to initialize upcase table.");
1752        return false;
1753}
1754
1755/*
1756 * The lcn and mft bitmap inodes are NTFS-internal inodes with
1757 * their own special locking rules:
1758 */
1759static struct lock_class_key
1760        lcnbmp_runlist_lock_key, lcnbmp_mrec_lock_key,
1761        mftbmp_runlist_lock_key, mftbmp_mrec_lock_key;
1762
1763/**
1764 * load_system_files - open the system files using normal functions
1765 * @vol:        ntfs super block describing device whose system files to load
1766 *
1767 * Open the system files with normal access functions and complete setting up
1768 * the ntfs super block @vol.
1769 *
1770 * Return 'true' on success or 'false' on error.
1771 */
1772static bool load_system_files(ntfs_volume *vol)
1773{
1774        struct super_block *sb = vol->sb;
1775        MFT_RECORD *m;
1776        VOLUME_INFORMATION *vi;
1777        ntfs_attr_search_ctx *ctx;
1778#ifdef NTFS_RW
1779        RESTART_PAGE_HEADER *rp;
1780        int err;
1781#endif /* NTFS_RW */
1782
1783        ntfs_debug("Entering.");
1784#ifdef NTFS_RW
1785        /* Get mft mirror inode compare the contents of $MFT and $MFTMirr. */
1786        if (!load_and_init_mft_mirror(vol) || !check_mft_mirror(vol)) {
1787                static const char *es1 = "Failed to load $MFTMirr";
1788                static const char *es2 = "$MFTMirr does not match $MFT";
1789                static const char *es3 = ".  Run ntfsfix and/or chkdsk.";
1790
1791                /* If a read-write mount, convert it to a read-only mount. */
1792                if (!(sb->s_flags & MS_RDONLY)) {
1793                        if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1794                                        ON_ERRORS_CONTINUE))) {
1795                                ntfs_error(sb, "%s and neither on_errors="
1796                                                "continue nor on_errors="
1797                                                "remount-ro was specified%s",
1798                                                !vol->mftmirr_ino ? es1 : es2,
1799                                                es3);
1800                                goto iput_mirr_err_out;
1801                        }
1802                        sb->s_flags |= MS_RDONLY;
1803                        ntfs_error(sb, "%s.  Mounting read-only%s",
1804                                        !vol->mftmirr_ino ? es1 : es2, es3);
1805                } else
1806                        ntfs_warning(sb, "%s.  Will not be able to remount "
1807                                        "read-write%s",
1808                                        !vol->mftmirr_ino ? es1 : es2, es3);
1809                /* This will prevent a read-write remount. */
1810                NVolSetErrors(vol);
1811        }
1812#endif /* NTFS_RW */
1813        /* Get mft bitmap attribute inode. */
1814        vol->mftbmp_ino = ntfs_attr_iget(vol->mft_ino, AT_BITMAP, NULL, 0);
1815        if (IS_ERR(vol->mftbmp_ino)) {
1816                ntfs_error(sb, "Failed to load $MFT/$BITMAP attribute.");
1817                goto iput_mirr_err_out;
1818        }
1819        lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->runlist.lock,
1820                           &mftbmp_runlist_lock_key);
1821        lockdep_set_class(&NTFS_I(vol->mftbmp_ino)->mrec_lock,
1822                           &mftbmp_mrec_lock_key);
1823        /* Read upcase table and setup @vol->upcase and @vol->upcase_len. */
1824        if (!load_and_init_upcase(vol))
1825                goto iput_mftbmp_err_out;
1826#ifdef NTFS_RW
1827        /*
1828         * Read attribute definitions table and setup @vol->attrdef and
1829         * @vol->attrdef_size.
1830         */
1831        if (!load_and_init_attrdef(vol))
1832                goto iput_upcase_err_out;
1833#endif /* NTFS_RW */
1834        /*
1835         * Get the cluster allocation bitmap inode and verify the size, no
1836         * need for any locking at this stage as we are already running
1837         * exclusively as we are mount in progress task.
1838         */
1839        vol->lcnbmp_ino = ntfs_iget(sb, FILE_Bitmap);
1840        if (IS_ERR(vol->lcnbmp_ino) || is_bad_inode(vol->lcnbmp_ino)) {
1841                if (!IS_ERR(vol->lcnbmp_ino))
1842                        iput(vol->lcnbmp_ino);
1843                goto bitmap_failed;
1844        }
1845        lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->runlist.lock,
1846                           &lcnbmp_runlist_lock_key);
1847        lockdep_set_class(&NTFS_I(vol->lcnbmp_ino)->mrec_lock,
1848                           &lcnbmp_mrec_lock_key);
1849
1850        NInoSetSparseDisabled(NTFS_I(vol->lcnbmp_ino));
1851        if ((vol->nr_clusters + 7) >> 3 > i_size_read(vol->lcnbmp_ino)) {
1852                iput(vol->lcnbmp_ino);
1853bitmap_failed:
1854                ntfs_error(sb, "Failed to load $Bitmap.");
1855                goto iput_attrdef_err_out;
1856        }
1857        /*
1858         * Get the volume inode and setup our cache of the volume flags and
1859         * version.
1860         */
1861        vol->vol_ino = ntfs_iget(sb, FILE_Volume);
1862        if (IS_ERR(vol->vol_ino) || is_bad_inode(vol->vol_ino)) {
1863                if (!IS_ERR(vol->vol_ino))
1864                        iput(vol->vol_ino);
1865volume_failed:
1866                ntfs_error(sb, "Failed to load $Volume.");
1867                goto iput_lcnbmp_err_out;
1868        }
1869        m = map_mft_record(NTFS_I(vol->vol_ino));
1870        if (IS_ERR(m)) {
1871iput_volume_failed:
1872                iput(vol->vol_ino);
1873                goto volume_failed;
1874        }
1875        if (!(ctx = ntfs_attr_get_search_ctx(NTFS_I(vol->vol_ino), m))) {
1876                ntfs_error(sb, "Failed to get attribute search context.");
1877                goto get_ctx_vol_failed;
1878        }
1879        if (ntfs_attr_lookup(AT_VOLUME_INFORMATION, NULL, 0, 0, 0, NULL, 0,
1880                        ctx) || ctx->attr->non_resident || ctx->attr->flags) {
1881err_put_vol:
1882                ntfs_attr_put_search_ctx(ctx);
1883get_ctx_vol_failed:
1884                unmap_mft_record(NTFS_I(vol->vol_ino));
1885                goto iput_volume_failed;
1886        }
1887        vi = (VOLUME_INFORMATION*)((char*)ctx->attr +
1888                        le16_to_cpu(ctx->attr->data.resident.value_offset));
1889        /* Some bounds checks. */
1890        if ((u8*)vi < (u8*)ctx->attr || (u8*)vi +
1891                        le32_to_cpu(ctx->attr->data.resident.value_length) >
1892                        (u8*)ctx->attr + le32_to_cpu(ctx->attr->length))
1893                goto err_put_vol;
1894        /* Copy the volume flags and version to the ntfs_volume structure. */
1895        vol->vol_flags = vi->flags;
1896        vol->major_ver = vi->major_ver;
1897        vol->minor_ver = vi->minor_ver;
1898        ntfs_attr_put_search_ctx(ctx);
1899        unmap_mft_record(NTFS_I(vol->vol_ino));
1900        pr_info("volume version %i.%i.\n", vol->major_ver,
1901                        vol->minor_ver);
1902        if (vol->major_ver < 3 && NVolSparseEnabled(vol)) {
1903                ntfs_warning(vol->sb, "Disabling sparse support due to NTFS "
1904                                "volume version %i.%i (need at least version "
1905                                "3.0).", vol->major_ver, vol->minor_ver);
1906                NVolClearSparseEnabled(vol);
1907        }
1908#ifdef NTFS_RW
1909        /* Make sure that no unsupported volume flags are set. */
1910        if (vol->vol_flags & VOLUME_MUST_MOUNT_RO_MASK) {
1911                static const char *es1a = "Volume is dirty";
1912                static const char *es1b = "Volume has been modified by chkdsk";
1913                static const char *es1c = "Volume has unsupported flags set";
1914                static const char *es2a = ".  Run chkdsk and mount in Windows.";
1915                static const char *es2b = ".  Mount in Windows.";
1916                const char *es1, *es2;
1917
1918                es2 = es2a;
1919                if (vol->vol_flags & VOLUME_IS_DIRTY)
1920                        es1 = es1a;
1921                else if (vol->vol_flags & VOLUME_MODIFIED_BY_CHKDSK) {
1922                        es1 = es1b;
1923                        es2 = es2b;
1924                } else {
1925                        es1 = es1c;
1926                        ntfs_warning(sb, "Unsupported volume flags 0x%x "
1927                                        "encountered.",
1928                                        (unsigned)le16_to_cpu(vol->vol_flags));
1929                }
1930                /* If a read-write mount, convert it to a read-only mount. */
1931                if (!(sb->s_flags & MS_RDONLY)) {
1932                        if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1933                                        ON_ERRORS_CONTINUE))) {
1934                                ntfs_error(sb, "%s and neither on_errors="
1935                                                "continue nor on_errors="
1936                                                "remount-ro was specified%s",
1937                                                es1, es2);
1938                                goto iput_vol_err_out;
1939                        }
1940                        sb->s_flags |= MS_RDONLY;
1941                        ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
1942                } else
1943                        ntfs_warning(sb, "%s.  Will not be able to remount "
1944                                        "read-write%s", es1, es2);
1945                /*
1946                 * Do not set NVolErrors() because ntfs_remount() re-checks the
1947                 * flags which we need to do in case any flags have changed.
1948                 */
1949        }
1950        /*
1951         * Get the inode for the logfile, check it and determine if the volume
1952         * was shutdown cleanly.
1953         */
1954        rp = NULL;
1955        if (!load_and_check_logfile(vol, &rp) ||
1956                        !ntfs_is_logfile_clean(vol->logfile_ino, rp)) {
1957                static const char *es1a = "Failed to load $LogFile";
1958                static const char *es1b = "$LogFile is not clean";
1959                static const char *es2 = ".  Mount in Windows.";
1960                const char *es1;
1961
1962                es1 = !vol->logfile_ino ? es1a : es1b;
1963                /* If a read-write mount, convert it to a read-only mount. */
1964                if (!(sb->s_flags & MS_RDONLY)) {
1965                        if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
1966                                        ON_ERRORS_CONTINUE))) {
1967                                ntfs_error(sb, "%s and neither on_errors="
1968                                                "continue nor on_errors="
1969                                                "remount-ro was specified%s",
1970                                                es1, es2);
1971                                if (vol->logfile_ino) {
1972                                        BUG_ON(!rp);
1973                                        ntfs_free(rp);
1974                                }
1975                                goto iput_logfile_err_out;
1976                        }
1977                        sb->s_flags |= MS_RDONLY;
1978                        ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
1979                } else
1980                        ntfs_warning(sb, "%s.  Will not be able to remount "
1981                                        "read-write%s", es1, es2);
1982                /* This will prevent a read-write remount. */
1983                NVolSetErrors(vol);
1984        }
1985        ntfs_free(rp);
1986#endif /* NTFS_RW */
1987        /* Get the root directory inode so we can do path lookups. */
1988        vol->root_ino = ntfs_iget(sb, FILE_root);
1989        if (IS_ERR(vol->root_ino) || is_bad_inode(vol->root_ino)) {
1990                if (!IS_ERR(vol->root_ino))
1991                        iput(vol->root_ino);
1992                ntfs_error(sb, "Failed to load root directory.");
1993                goto iput_logfile_err_out;
1994        }
1995#ifdef NTFS_RW
1996        /*
1997         * Check if Windows is suspended to disk on the target volume.  If it
1998         * is hibernated, we must not write *anything* to the disk so set
1999         * NVolErrors() without setting the dirty volume flag and mount
2000         * read-only.  This will prevent read-write remounting and it will also
2001         * prevent all writes.
2002         */
2003        err = check_windows_hibernation_status(vol);
2004        if (unlikely(err)) {
2005                static const char *es1a = "Failed to determine if Windows is "
2006                                "hibernated";
2007                static const char *es1b = "Windows is hibernated";
2008                static const char *es2 = ".  Run chkdsk.";
2009                const char *es1;
2010
2011                es1 = err < 0 ? es1a : es1b;
2012                /* If a read-write mount, convert it to a read-only mount. */
2013                if (!(sb->s_flags & MS_RDONLY)) {
2014                        if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2015                                        ON_ERRORS_CONTINUE))) {
2016                                ntfs_error(sb, "%s and neither on_errors="
2017                                                "continue nor on_errors="
2018                                                "remount-ro was specified%s",
2019                                                es1, es2);
2020                                goto iput_root_err_out;
2021                        }
2022                        sb->s_flags |= MS_RDONLY;
2023                        ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2024                } else
2025                        ntfs_warning(sb, "%s.  Will not be able to remount "
2026                                        "read-write%s", es1, es2);
2027                /* This will prevent a read-write remount. */
2028                NVolSetErrors(vol);
2029        }
2030        /* If (still) a read-write mount, mark the volume dirty. */
2031        if (!(sb->s_flags & MS_RDONLY) &&
2032                        ntfs_set_volume_flags(vol, VOLUME_IS_DIRTY)) {
2033                static const char *es1 = "Failed to set dirty bit in volume "
2034                                "information flags";
2035                static const char *es2 = ".  Run chkdsk.";
2036
2037                /* Convert to a read-only mount. */
2038                if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2039                                ON_ERRORS_CONTINUE))) {
2040                        ntfs_error(sb, "%s and neither on_errors=continue nor "
2041                                        "on_errors=remount-ro was specified%s",
2042                                        es1, es2);
2043                        goto iput_root_err_out;
2044                }
2045                ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2046                sb->s_flags |= MS_RDONLY;
2047                /*
2048                 * Do not set NVolErrors() because ntfs_remount() might manage
2049                 * to set the dirty flag in which case all would be well.
2050                 */
2051        }
2052#if 0
2053        // TODO: Enable this code once we start modifying anything that is
2054        //       different between NTFS 1.2 and 3.x...
2055        /*
2056         * If (still) a read-write mount, set the NT4 compatibility flag on
2057         * newer NTFS version volumes.
2058         */
2059        if (!(sb->s_flags & MS_RDONLY) && (vol->major_ver > 1) &&
2060                        ntfs_set_volume_flags(vol, VOLUME_MOUNTED_ON_NT4)) {
2061                static const char *es1 = "Failed to set NT4 compatibility flag";
2062                static const char *es2 = ".  Run chkdsk.";
2063
2064                /* Convert to a read-only mount. */
2065                if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2066                                ON_ERRORS_CONTINUE))) {
2067                        ntfs_error(sb, "%s and neither on_errors=continue nor "
2068                                        "on_errors=remount-ro was specified%s",
2069                                        es1, es2);
2070                        goto iput_root_err_out;
2071                }
2072                ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2073                sb->s_flags |= MS_RDONLY;
2074                NVolSetErrors(vol);
2075        }
2076#endif
2077        /* If (still) a read-write mount, empty the logfile. */
2078        if (!(sb->s_flags & MS_RDONLY) &&
2079                        !ntfs_empty_logfile(vol->logfile_ino)) {
2080                static const char *es1 = "Failed to empty $LogFile";
2081                static const char *es2 = ".  Mount in Windows.";
2082
2083                /* Convert to a read-only mount. */
2084                if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2085                                ON_ERRORS_CONTINUE))) {
2086                        ntfs_error(sb, "%s and neither on_errors=continue nor "
2087                                        "on_errors=remount-ro was specified%s",
2088                                        es1, es2);
2089                        goto iput_root_err_out;
2090                }
2091                ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2092                sb->s_flags |= MS_RDONLY;
2093                NVolSetErrors(vol);
2094        }
2095#endif /* NTFS_RW */
2096        /* If on NTFS versions before 3.0, we are done. */
2097        if (unlikely(vol->major_ver < 3))
2098                return true;
2099        /* NTFS 3.0+ specific initialization. */
2100        /* Get the security descriptors inode. */
2101        vol->secure_ino = ntfs_iget(sb, FILE_Secure);
2102        if (IS_ERR(vol->secure_ino) || is_bad_inode(vol->secure_ino)) {
2103                if (!IS_ERR(vol->secure_ino))
2104                        iput(vol->secure_ino);
2105                ntfs_error(sb, "Failed to load $Secure.");
2106                goto iput_root_err_out;
2107        }
2108        // TODO: Initialize security.
2109        /* Get the extended system files' directory inode. */
2110        vol->extend_ino = ntfs_iget(sb, FILE_Extend);
2111        if (IS_ERR(vol->extend_ino) || is_bad_inode(vol->extend_ino)) {
2112                if (!IS_ERR(vol->extend_ino))
2113                        iput(vol->extend_ino);
2114                ntfs_error(sb, "Failed to load $Extend.");
2115                goto iput_sec_err_out;
2116        }
2117#ifdef NTFS_RW
2118        /* Find the quota file, load it if present, and set it up. */
2119        if (!load_and_init_quota(vol)) {
2120                static const char *es1 = "Failed to load $Quota";
2121                static const char *es2 = ".  Run chkdsk.";
2122
2123                /* If a read-write mount, convert it to a read-only mount. */
2124                if (!(sb->s_flags & MS_RDONLY)) {
2125                        if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2126                                        ON_ERRORS_CONTINUE))) {
2127                                ntfs_error(sb, "%s and neither on_errors="
2128                                                "continue nor on_errors="
2129                                                "remount-ro was specified%s",
2130                                                es1, es2);
2131                                goto iput_quota_err_out;
2132                        }
2133                        sb->s_flags |= MS_RDONLY;
2134                        ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2135                } else
2136                        ntfs_warning(sb, "%s.  Will not be able to remount "
2137                                        "read-write%s", es1, es2);
2138                /* This will prevent a read-write remount. */
2139                NVolSetErrors(vol);
2140        }
2141        /* If (still) a read-write mount, mark the quotas out of date. */
2142        if (!(sb->s_flags & MS_RDONLY) &&
2143                        !ntfs_mark_quotas_out_of_date(vol)) {
2144                static const char *es1 = "Failed to mark quotas out of date";
2145                static const char *es2 = ".  Run chkdsk.";
2146
2147                /* Convert to a read-only mount. */
2148                if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2149                                ON_ERRORS_CONTINUE))) {
2150                        ntfs_error(sb, "%s and neither on_errors=continue nor "
2151                                        "on_errors=remount-ro was specified%s",
2152                                        es1, es2);
2153                        goto iput_quota_err_out;
2154                }
2155                ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2156                sb->s_flags |= MS_RDONLY;
2157                NVolSetErrors(vol);
2158        }
2159        /*
2160         * Find the transaction log file ($UsnJrnl), load it if present, check
2161         * it, and set it up.
2162         */
2163        if (!load_and_init_usnjrnl(vol)) {
2164                static const char *es1 = "Failed to load $UsnJrnl";
2165                static const char *es2 = ".  Run chkdsk.";
2166
2167                /* If a read-write mount, convert it to a read-only mount. */
2168                if (!(sb->s_flags & MS_RDONLY)) {
2169                        if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2170                                        ON_ERRORS_CONTINUE))) {
2171                                ntfs_error(sb, "%s and neither on_errors="
2172                                                "continue nor on_errors="
2173                                                "remount-ro was specified%s",
2174                                                es1, es2);
2175                                goto iput_usnjrnl_err_out;
2176                        }
2177                        sb->s_flags |= MS_RDONLY;
2178                        ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2179                } else
2180                        ntfs_warning(sb, "%s.  Will not be able to remount "
2181                                        "read-write%s", es1, es2);
2182                /* This will prevent a read-write remount. */
2183                NVolSetErrors(vol);
2184        }
2185        /* If (still) a read-write mount, stamp the transaction log. */
2186        if (!(sb->s_flags & MS_RDONLY) && !ntfs_stamp_usnjrnl(vol)) {
2187                static const char *es1 = "Failed to stamp transaction log "
2188                                "($UsnJrnl)";
2189                static const char *es2 = ".  Run chkdsk.";
2190
2191                /* Convert to a read-only mount. */
2192                if (!(vol->on_errors & (ON_ERRORS_REMOUNT_RO |
2193                                ON_ERRORS_CONTINUE))) {
2194                        ntfs_error(sb, "%s and neither on_errors=continue nor "
2195                                        "on_errors=remount-ro was specified%s",
2196                                        es1, es2);
2197                        goto iput_usnjrnl_err_out;
2198                }
2199                ntfs_error(sb, "%s.  Mounting read-only%s", es1, es2);
2200                sb->s_flags |= MS_RDONLY;
2201                NVolSetErrors(vol);
2202        }
2203#endif /* NTFS_RW */
2204        return true;
2205#ifdef NTFS_RW
2206iput_usnjrnl_err_out:
2207        if (vol->usnjrnl_j_ino)
2208                iput(vol->usnjrnl_j_ino);
2209        if (vol->usnjrnl_max_ino)
2210                iput(vol->usnjrnl_max_ino);
2211        if (vol->usnjrnl_ino)
2212                iput(vol->usnjrnl_ino);
2213iput_quota_err_out:
2214        if (vol->quota_q_ino)
2215                iput(vol->quota_q_ino);
2216        if (vol->quota_ino)
2217                iput(vol->quota_ino);
2218        iput(vol->extend_ino);
2219#endif /* NTFS_RW */
2220iput_sec_err_out:
2221        iput(vol->secure_ino);
2222iput_root_err_out:
2223        iput(vol->root_ino);
2224iput_logfile_err_out:
2225#ifdef NTFS_RW
2226        if (vol->logfile_ino)
2227                iput(vol->logfile_ino);
2228iput_vol_err_out:
2229#endif /* NTFS_RW */
2230        iput(vol->vol_ino);
2231iput_lcnbmp_err_out:
2232        iput(vol->lcnbmp_ino);
2233iput_attrdef_err_out:
2234        vol->attrdef_size = 0;
2235        if (vol->attrdef) {
2236                ntfs_free(vol->attrdef);
2237                vol->attrdef = NULL;
2238        }
2239#ifdef NTFS_RW
2240iput_upcase_err_out:
2241#endif /* NTFS_RW */
2242        vol->upcase_len = 0;
2243        mutex_lock(&ntfs_lock);
2244        if (vol->upcase == default_upcase) {
2245                ntfs_nr_upcase_users--;
2246                vol->upcase = NULL;
2247        }
2248        mutex_unlock(&ntfs_lock);
2249        if (vol->upcase) {
2250                ntfs_free(vol->upcase);
2251                vol->upcase = NULL;
2252        }
2253iput_mftbmp_err_out:
2254        iput(vol->mftbmp_ino);
2255iput_mirr_err_out:
2256#ifdef NTFS_RW
2257        if (vol->mftmirr_ino)
2258                iput(vol->mftmirr_ino);
2259#endif /* NTFS_RW */
2260        return false;
2261}
2262
2263/**
2264 * ntfs_put_super - called by the vfs to unmount a volume
2265 * @sb:         vfs superblock of volume to unmount
2266 *
2267 * ntfs_put_super() is called by the VFS (from fs/super.c::do_umount()) when
2268 * the volume is being unmounted (umount system call has been invoked) and it
2269 * releases all inodes and memory belonging to the NTFS specific part of the
2270 * super block.
2271 */
2272static void ntfs_put_super(struct super_block *sb)
2273{
2274        ntfs_volume *vol = NTFS_SB(sb);
2275
2276        ntfs_debug("Entering.");
2277
2278#ifdef NTFS_RW
2279        /*
2280         * Commit all inodes while they are still open in case some of them
2281         * cause others to be dirtied.
2282         */
2283        ntfs_commit_inode(vol->vol_ino);
2284
2285        /* NTFS 3.0+ specific. */
2286        if (vol->major_ver >= 3) {
2287                if (vol->usnjrnl_j_ino)
2288                        ntfs_commit_inode(vol->usnjrnl_j_ino);
2289                if (vol->usnjrnl_max_ino)
2290                        ntfs_commit_inode(vol->usnjrnl_max_ino);
2291                if (vol->usnjrnl_ino)
2292                        ntfs_commit_inode(vol->usnjrnl_ino);
2293                if (vol->quota_q_ino)
2294                        ntfs_commit_inode(vol->quota_q_ino);
2295                if (vol->quota_ino)
2296                        ntfs_commit_inode(vol->quota_ino);
2297                if (vol->extend_ino)
2298                        ntfs_commit_inode(vol->extend_ino);
2299                if (vol->secure_ino)
2300                        ntfs_commit_inode(vol->secure_ino);
2301        }
2302
2303        ntfs_commit_inode(vol->root_ino);
2304
2305        down_write(&vol->lcnbmp_lock);
2306        ntfs_commit_inode(vol->lcnbmp_ino);
2307        up_write(&vol->lcnbmp_lock);
2308
2309        down_write(&vol->mftbmp_lock);
2310        ntfs_commit_inode(vol->mftbmp_ino);
2311        up_write(&vol->mftbmp_lock);
2312
2313        if (vol->logfile_ino)
2314                ntfs_commit_inode(vol->logfile_ino);
2315
2316        if (vol->mftmirr_ino)
2317                ntfs_commit_inode(vol->mftmirr_ino);
2318        ntfs_commit_inode(vol->mft_ino);
2319
2320        /*
2321         * If a read-write mount and no volume errors have occurred, mark the
2322         * volume clean.  Also, re-commit all affected inodes.
2323         */
2324        if (!(sb->s_flags & MS_RDONLY)) {
2325                if (!NVolErrors(vol)) {
2326                        if (ntfs_clear_volume_flags(vol, VOLUME_IS_DIRTY))
2327                                ntfs_warning(sb, "Failed to clear dirty bit "
2328                                                "in volume information "
2329                                                "flags.  Run chkdsk.");
2330                        ntfs_commit_inode(vol->vol_ino);
2331                        ntfs_commit_inode(vol->root_ino);
2332                        if (vol->mftmirr_ino)
2333                                ntfs_commit_inode(vol->mftmirr_ino);
2334                        ntfs_commit_inode(vol->mft_ino);
2335                } else {
2336                        ntfs_warning(sb, "Volume has errors.  Leaving volume "
2337                                        "marked dirty.  Run chkdsk.");
2338                }
2339        }
2340#endif /* NTFS_RW */
2341
2342        iput(vol->vol_ino);
2343        vol->vol_ino = NULL;
2344
2345        /* NTFS 3.0+ specific clean up. */
2346        if (vol->major_ver >= 3) {
2347#ifdef NTFS_RW
2348                if (vol->usnjrnl_j_ino) {
2349                        iput(vol->usnjrnl_j_ino);
2350                        vol->usnjrnl_j_ino = NULL;
2351                }
2352                if (vol->usnjrnl_max_ino) {
2353                        iput(vol->usnjrnl_max_ino);
2354                        vol->usnjrnl_max_ino = NULL;
2355                }
2356                if (vol->usnjrnl_ino) {
2357                        iput(vol->usnjrnl_ino);
2358                        vol->usnjrnl_ino = NULL;
2359                }
2360                if (vol->quota_q_ino) {
2361                        iput(vol->quota_q_ino);
2362                        vol->quota_q_ino = NULL;
2363                }
2364                if (vol->quota_ino) {
2365                        iput(vol->quota_ino);
2366                        vol->quota_ino = NULL;
2367                }
2368#endif /* NTFS_RW */
2369                if (vol->extend_ino) {
2370                        iput(vol->extend_ino);
2371                        vol->extend_ino = NULL;
2372                }
2373                if (vol->secure_ino) {
2374                        iput(vol->secure_ino);
2375                        vol->secure_ino = NULL;
2376                }
2377        }
2378
2379        iput(vol->root_ino);
2380        vol->root_ino = NULL;
2381
2382        down_write(&vol->lcnbmp_lock);
2383        iput(vol->lcnbmp_ino);
2384        vol->lcnbmp_ino = NULL;
2385        up_write(&vol->lcnbmp_lock);
2386
2387        down_write(&vol->mftbmp_lock);
2388        iput(vol->mftbmp_ino);
2389        vol->mftbmp_ino = NULL;
2390        up_write(&vol->mftbmp_lock);
2391
2392#ifdef NTFS_RW
2393        if (vol->logfile_ino) {
2394                iput(vol->logfile_ino);
2395                vol->logfile_ino = NULL;
2396        }
2397        if (vol->mftmirr_ino) {
2398                /* Re-commit the mft mirror and mft just in case. */
2399                ntfs_commit_inode(vol->mftmirr_ino);
2400                ntfs_commit_inode(vol->mft_ino);
2401                iput(vol->mftmirr_ino);
2402                vol->mftmirr_ino = NULL;
2403        }
2404        /*
2405         * We should have no dirty inodes left, due to
2406         * mft.c::ntfs_mft_writepage() cleaning all the dirty pages as
2407         * the underlying mft records are written out and cleaned.
2408         */
2409        ntfs_commit_inode(vol->mft_ino);
2410        write_inode_now(vol->mft_ino, 1);
2411#endif /* NTFS_RW */
2412
2413        iput(vol->mft_ino);
2414        vol->mft_ino = NULL;
2415
2416        /* Throw away the table of attribute definitions. */
2417        vol->attrdef_size = 0;
2418        if (vol->attrdef) {
2419                ntfs_free(vol->attrdef);
2420                vol->attrdef = NULL;
2421        }
2422        vol->upcase_len = 0;
2423        /*
2424         * Destroy the global default upcase table if necessary.  Also decrease
2425         * the number of upcase users if we are a user.
2426         */
2427        mutex_lock(&ntfs_lock);
2428        if (vol->upcase == default_upcase) {
2429                ntfs_nr_upcase_users--;
2430                vol->upcase = NULL;
2431        }
2432        if (!ntfs_nr_upcase_users && default_upcase) {
2433                ntfs_free(default_upcase);
2434                default_upcase = NULL;
2435        }
2436        if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
2437                free_compression_buffers();
2438        mutex_unlock(&ntfs_lock);
2439        if (vol->upcase) {
2440                ntfs_free(vol->upcase);
2441                vol->upcase = NULL;
2442        }
2443
2444        unload_nls(vol->nls_map);
2445
2446        sb->s_fs_info = NULL;
2447        kfree(vol);
2448}
2449
2450/**
2451 * get_nr_free_clusters - return the number of free clusters on a volume
2452 * @vol:        ntfs volume for which to obtain free cluster count
2453 *
2454 * Calculate the number of free clusters on the mounted NTFS volume @vol. We
2455 * actually calculate the number of clusters in use instead because this
2456 * allows us to not care about partial pages as these will be just zero filled
2457 * and hence not be counted as allocated clusters.
2458 *
2459 * The only particularity is that clusters beyond the end of the logical ntfs
2460 * volume will be marked as allocated to prevent errors which means we have to
2461 * discount those at the end. This is important as the cluster bitmap always
2462 * has a size in multiples of 8 bytes, i.e. up to 63 clusters could be outside
2463 * the logical volume and marked in use when they are not as they do not exist.
2464 *
2465 * If any pages cannot be read we assume all clusters in the erroring pages are
2466 * in use. This means we return an underestimate on errors which is better than
2467 * an overestimate.
2468 */
2469static s64 get_nr_free_clusters(ntfs_volume *vol)
2470{
2471        s64 nr_free = vol->nr_clusters;
2472        struct address_space *mapping = vol->lcnbmp_ino->i_mapping;
2473        struct page *page;
2474        pgoff_t index, max_index;
2475
2476        ntfs_debug("Entering.");
2477        /* Serialize accesses to the cluster bitmap. */
2478        down_read(&vol->lcnbmp_lock);
2479        /*
2480         * Convert the number of bits into bytes rounded up, then convert into
2481         * multiples of PAGE_CACHE_SIZE, rounding up so that if we have one
2482         * full and one partial page max_index = 2.
2483         */
2484        max_index = (((vol->nr_clusters + 7) >> 3) + PAGE_CACHE_SIZE - 1) >>
2485                        PAGE_CACHE_SHIFT;
2486        /* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
2487        ntfs_debug("Reading $Bitmap, max_index = 0x%lx, max_size = 0x%lx.",
2488                        max_index, PAGE_CACHE_SIZE / 4);
2489        for (index = 0; index < max_index; index++) {
2490                unsigned long *kaddr;
2491
2492                /*
2493                 * Read the page from page cache, getting it from backing store
2494                 * if necessary, and increment the use count.
2495                 */
2496                page = read_mapping_page(mapping, index, NULL);
2497                /* Ignore pages which errored synchronously. */
2498                if (IS_ERR(page)) {
2499                        ntfs_debug("read_mapping_page() error. Skipping "
2500                                        "page (index 0x%lx).", index);
2501                        nr_free -= PAGE_CACHE_SIZE * 8;
2502                        continue;
2503                }
2504                kaddr = kmap_atomic(page);
2505                /*
2506                 * Subtract the number of set bits. If this
2507                 * is the last page and it is partial we don't really care as
2508                 * it just means we do a little extra work but it won't affect
2509                 * the result as all out of range bytes are set to zero by
2510                 * ntfs_readpage().
2511                 */
2512                nr_free -= bitmap_weight(kaddr,
2513                                        PAGE_CACHE_SIZE * BITS_PER_BYTE);
2514                kunmap_atomic(kaddr);
2515                page_cache_release(page);
2516        }
2517        ntfs_debug("Finished reading $Bitmap, last index = 0x%lx.", index - 1);
2518        /*
2519         * Fixup for eventual bits outside logical ntfs volume (see function
2520         * description above).
2521         */
2522        if (vol->nr_clusters & 63)
2523                nr_free += 64 - (vol->nr_clusters & 63);
2524        up_read(&vol->lcnbmp_lock);
2525        /* If errors occurred we may well have gone below zero, fix this. */
2526        if (nr_free < 0)
2527                nr_free = 0;
2528        ntfs_debug("Exiting.");
2529        return nr_free;
2530}
2531
2532/**
2533 * __get_nr_free_mft_records - return the number of free inodes on a volume
2534 * @vol:        ntfs volume for which to obtain free inode count
2535 * @nr_free:    number of mft records in filesystem
2536 * @max_index:  maximum number of pages containing set bits
2537 *
2538 * Calculate the number of free mft records (inodes) on the mounted NTFS
2539 * volume @vol. We actually calculate the number of mft records in use instead
2540 * because this allows us to not care about partial pages as these will be just
2541 * zero filled and hence not be counted as allocated mft record.
2542 *
2543 * If any pages cannot be read we assume all mft records in the erroring pages
2544 * are in use. This means we return an underestimate on errors which is better
2545 * than an overestimate.
2546 *
2547 * NOTE: Caller must hold mftbmp_lock rw_semaphore for reading or writing.
2548 */
2549static unsigned long __get_nr_free_mft_records(ntfs_volume *vol,
2550                s64 nr_free, const pgoff_t max_index)
2551{
2552        struct address_space *mapping = vol->mftbmp_ino->i_mapping;
2553        struct page *page;
2554        pgoff_t index;
2555
2556        ntfs_debug("Entering.");
2557        /* Use multiples of 4 bytes, thus max_size is PAGE_CACHE_SIZE / 4. */
2558        ntfs_debug("Reading $MFT/$BITMAP, max_index = 0x%lx, max_size = "
2559                        "0x%lx.", max_index, PAGE_CACHE_SIZE / 4);
2560        for (index = 0; index < max_index; index++) {
2561                unsigned long *kaddr;
2562
2563                /*
2564                 * Read the page from page cache, getting it from backing store
2565                 * if necessary, and increment the use count.
2566                 */
2567                page = read_mapping_page(mapping, index, NULL);
2568                /* Ignore pages which errored synchronously. */
2569                if (IS_ERR(page)) {
2570                        ntfs_debug("read_mapping_page() error. Skipping "
2571                                        "page (index 0x%lx).", index);
2572                        nr_free -= PAGE_CACHE_SIZE * 8;
2573                        continue;
2574                }
2575                kaddr = kmap_atomic(page);
2576                /*
2577                 * Subtract the number of set bits. If this
2578                 * is the last page and it is partial we don't really care as
2579                 * it just means we do a little extra work but it won't affect
2580                 * the result as all out of range bytes are set to zero by
2581                 * ntfs_readpage().
2582                 */
2583                nr_free -= bitmap_weight(kaddr,
2584                                        PAGE_CACHE_SIZE * BITS_PER_BYTE);
2585                kunmap_atomic(kaddr);
2586                page_cache_release(page);
2587        }
2588        ntfs_debug("Finished reading $MFT/$BITMAP, last index = 0x%lx.",
2589                        index - 1);
2590        /* If errors occurred we may well have gone below zero, fix this. */
2591        if (nr_free < 0)
2592                nr_free = 0;
2593        ntfs_debug("Exiting.");
2594        return nr_free;
2595}
2596
2597/**
2598 * ntfs_statfs - return information about mounted NTFS volume
2599 * @dentry:     dentry from mounted volume
2600 * @sfs:        statfs structure in which to return the information
2601 *
2602 * Return information about the mounted NTFS volume @dentry in the statfs structure
2603 * pointed to by @sfs (this is initialized with zeros before ntfs_statfs is
2604 * called). We interpret the values to be correct of the moment in time at
2605 * which we are called. Most values are variable otherwise and this isn't just
2606 * the free values but the totals as well. For example we can increase the
2607 * total number of file nodes if we run out and we can keep doing this until
2608 * there is no more space on the volume left at all.
2609 *
2610 * Called from vfs_statfs which is used to handle the statfs, fstatfs, and
2611 * ustat system calls.
2612 *
2613 * Return 0 on success or -errno on error.
2614 */
2615static int ntfs_statfs(struct dentry *dentry, struct kstatfs *sfs)
2616{
2617        struct super_block *sb = dentry->d_sb;
2618        s64 size;
2619        ntfs_volume *vol = NTFS_SB(sb);
2620        ntfs_inode *mft_ni = NTFS_I(vol->mft_ino);
2621        pgoff_t max_index;
2622        unsigned long flags;
2623
2624        ntfs_debug("Entering.");
2625        /* Type of filesystem. */
2626        sfs->f_type   = NTFS_SB_MAGIC;
2627        /* Optimal transfer block size. */
2628        sfs->f_bsize  = PAGE_CACHE_SIZE;
2629        /*
2630         * Total data blocks in filesystem in units of f_bsize and since
2631         * inodes are also stored in data blocs ($MFT is a file) this is just
2632         * the total clusters.
2633         */
2634        sfs->f_blocks = vol->nr_clusters << vol->cluster_size_bits >>
2635                                PAGE_CACHE_SHIFT;
2636        /* Free data blocks in filesystem in units of f_bsize. */
2637        size          = get_nr_free_clusters(vol) << vol->cluster_size_bits >>
2638                                PAGE_CACHE_SHIFT;
2639        if (size < 0LL)
2640                size = 0LL;
2641        /* Free blocks avail to non-superuser, same as above on NTFS. */
2642        sfs->f_bavail = sfs->f_bfree = size;
2643        /* Serialize accesses to the inode bitmap. */
2644        down_read(&vol->mftbmp_lock);
2645        read_lock_irqsave(&mft_ni->size_lock, flags);
2646        size = i_size_read(vol->mft_ino) >> vol->mft_record_size_bits;
2647        /*
2648         * Convert the maximum number of set bits into bytes rounded up, then
2649         * convert into multiples of PAGE_CACHE_SIZE, rounding up so that if we
2650         * have one full and one partial page max_index = 2.
2651         */
2652        max_index = ((((mft_ni->initialized_size >> vol->mft_record_size_bits)
2653                        + 7) >> 3) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
2654        read_unlock_irqrestore(&mft_ni->size_lock, flags);
2655        /* Number of inodes in filesystem (at this point in time). */
2656        sfs->f_files = size;
2657        /* Free inodes in fs (based on current total count). */
2658        sfs->f_ffree = __get_nr_free_mft_records(vol, size, max_index);
2659        up_read(&vol->mftbmp_lock);
2660        /*
2661         * File system id. This is extremely *nix flavour dependent and even
2662         * within Linux itself all fs do their own thing. I interpret this to
2663         * mean a unique id associated with the mounted fs and not the id
2664         * associated with the filesystem driver, the latter is already given
2665         * by the filesystem type in sfs->f_type. Thus we use the 64-bit
2666         * volume serial number splitting it into two 32-bit parts. We enter
2667         * the least significant 32-bits in f_fsid[0] and the most significant
2668         * 32-bits in f_fsid[1].
2669         */
2670        sfs->f_fsid.val[0] = vol->serial_no & 0xffffffff;
2671        sfs->f_fsid.val[1] = (vol->serial_no >> 32) & 0xffffffff;
2672        /* Maximum length of filenames. */
2673        sfs->f_namelen     = NTFS_MAX_NAME_LEN;
2674        return 0;
2675}
2676
2677#ifdef NTFS_RW
2678static int ntfs_write_inode(struct inode *vi, struct writeback_control *wbc)
2679{
2680        return __ntfs_write_inode(vi, wbc->sync_mode == WB_SYNC_ALL);
2681}
2682#endif
2683
2684/**
2685 * The complete super operations.
2686 */
2687static const struct super_operations ntfs_sops = {
2688        .alloc_inode    = ntfs_alloc_big_inode,   /* VFS: Allocate new inode. */
2689        .destroy_inode  = ntfs_destroy_big_inode, /* VFS: Deallocate inode. */
2690#ifdef NTFS_RW
2691        .write_inode    = ntfs_write_inode,     /* VFS: Write dirty inode to
2692                                                   disk. */
2693#endif /* NTFS_RW */
2694        .put_super      = ntfs_put_super,       /* Syscall: umount. */
2695        .statfs         = ntfs_statfs,          /* Syscall: statfs */
2696        .remount_fs     = ntfs_remount,         /* Syscall: mount -o remount. */
2697        .evict_inode    = ntfs_evict_big_inode, /* VFS: Called when an inode is
2698                                                   removed from memory. */
2699        .show_options   = ntfs_show_options,    /* Show mount options in
2700                                                   proc. */
2701};
2702
2703/**
2704 * ntfs_fill_super - mount an ntfs filesystem
2705 * @sb:         super block of ntfs filesystem to mount
2706 * @opt:        string containing the mount options
2707 * @silent:     silence error output
2708 *
2709 * ntfs_fill_super() is called by the VFS to mount the device described by @sb
2710 * with the mount otions in @data with the NTFS filesystem.
2711 *
2712 * If @silent is true, remain silent even if errors are detected. This is used
2713 * during bootup, when the kernel tries to mount the root filesystem with all
2714 * registered filesystems one after the other until one succeeds. This implies
2715 * that all filesystems except the correct one will quite correctly and
2716 * expectedly return an error, but nobody wants to see error messages when in
2717 * fact this is what is supposed to happen.
2718 *
2719 * NOTE: @sb->s_flags contains the mount options flags.
2720 */
2721static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
2722{
2723        ntfs_volume *vol;
2724        struct buffer_head *bh;
2725        struct inode *tmp_ino;
2726        int blocksize, result;
2727
2728        /*
2729         * We do a pretty difficult piece of bootstrap by reading the
2730         * MFT (and other metadata) from disk into memory. We'll only
2731         * release this metadata during umount, so the locking patterns
2732         * observed during bootstrap do not count. So turn off the
2733         * observation of locking patterns (strictly for this context
2734         * only) while mounting NTFS. [The validator is still active
2735         * otherwise, even for this context: it will for example record
2736         * lock class registrations.]
2737         */
2738        lockdep_off();
2739        ntfs_debug("Entering.");
2740#ifndef NTFS_RW
2741        sb->s_flags |= MS_RDONLY;
2742#endif /* ! NTFS_RW */
2743        /* Allocate a new ntfs_volume and place it in sb->s_fs_info. */
2744        sb->s_fs_info = kmalloc(sizeof(ntfs_volume), GFP_NOFS);
2745        vol = NTFS_SB(sb);
2746        if (!vol) {
2747                if (!silent)
2748                        ntfs_error(sb, "Allocation of NTFS volume structure "
2749                                        "failed. Aborting mount...");
2750                lockdep_on();
2751                return -ENOMEM;
2752        }
2753        /* Initialize ntfs_volume structure. */
2754        *vol = (ntfs_volume) {
2755                .sb = sb,
2756                /*
2757                 * Default is group and other don't have any access to files or
2758                 * directories while owner has full access. Further, files by
2759                 * default are not executable but directories are of course
2760                 * browseable.
2761                 */
2762                .fmask = 0177,
2763                .dmask = 0077,
2764        };
2765        init_rwsem(&vol->mftbmp_lock);
2766        init_rwsem(&vol->lcnbmp_lock);
2767
2768        /* By default, enable sparse support. */
2769        NVolSetSparseEnabled(vol);
2770
2771        /* Important to get the mount options dealt with now. */
2772        if (!parse_options(vol, (char*)opt))
2773                goto err_out_now;
2774
2775        /* We support sector sizes up to the PAGE_CACHE_SIZE. */
2776        if (bdev_logical_block_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
2777                if (!silent)
2778                        ntfs_error(sb, "Device has unsupported sector size "
2779                                        "(%i).  The maximum supported sector "
2780                                        "size on this architecture is %lu "
2781                                        "bytes.",
2782                                        bdev_logical_block_size(sb->s_bdev),
2783                                        PAGE_CACHE_SIZE);
2784                goto err_out_now;
2785        }
2786        /*
2787         * Setup the device access block size to NTFS_BLOCK_SIZE or the hard
2788         * sector size, whichever is bigger.
2789         */
2790        blocksize = sb_min_blocksize(sb, NTFS_BLOCK_SIZE);
2791        if (blocksize < NTFS_BLOCK_SIZE) {
2792                if (!silent)
2793                        ntfs_error(sb, "Unable to set device block size.");
2794                goto err_out_now;
2795        }
2796        BUG_ON(blocksize != sb->s_blocksize);
2797        ntfs_debug("Set device block size to %i bytes (block size bits %i).",
2798                        blocksize, sb->s_blocksize_bits);
2799        /* Determine the size of the device in units of block_size bytes. */
2800        if (!i_size_read(sb->s_bdev->bd_inode)) {
2801                if (!silent)
2802                        ntfs_error(sb, "Unable to determine device size.");
2803                goto err_out_now;
2804        }
2805        vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2806                        sb->s_blocksize_bits;
2807        /* Read the boot sector and return unlocked buffer head to it. */
2808        if (!(bh = read_ntfs_boot_sector(sb, silent))) {
2809                if (!silent)
2810                        ntfs_error(sb, "Not an NTFS volume.");
2811                goto err_out_now;
2812        }
2813        /*
2814         * Extract the data from the boot sector and setup the ntfs volume
2815         * using it.
2816         */
2817        result = parse_ntfs_boot_sector(vol, (NTFS_BOOT_SECTOR*)bh->b_data);
2818        brelse(bh);
2819        if (!result) {
2820                if (!silent)
2821                        ntfs_error(sb, "Unsupported NTFS filesystem.");
2822                goto err_out_now;
2823        }
2824        /*
2825         * If the boot sector indicates a sector size bigger than the current
2826         * device block size, switch the device block size to the sector size.
2827         * TODO: It may be possible to support this case even when the set
2828         * below fails, we would just be breaking up the i/o for each sector
2829         * into multiple blocks for i/o purposes but otherwise it should just
2830         * work.  However it is safer to leave disabled until someone hits this
2831         * error message and then we can get them to try it without the setting
2832         * so we know for sure that it works.
2833         */
2834        if (vol->sector_size > blocksize) {
2835                blocksize = sb_set_blocksize(sb, vol->sector_size);
2836                if (blocksize != vol->sector_size) {
2837                        if (!silent)
2838                                ntfs_error(sb, "Unable to set device block "
2839                                                "size to sector size (%i).",
2840                                                vol->sector_size);
2841                        goto err_out_now;
2842                }
2843                BUG_ON(blocksize != sb->s_blocksize);
2844                vol->nr_blocks = i_size_read(sb->s_bdev->bd_inode) >>
2845                                sb->s_blocksize_bits;
2846                ntfs_debug("Changed device block size to %i bytes (block size "
2847                                "bits %i) to match volume sector size.",
2848                                blocksize, sb->s_blocksize_bits);
2849        }
2850        /* Initialize the cluster and mft allocators. */
2851        ntfs_setup_allocators(vol);
2852        /* Setup remaining fields in the super block. */
2853        sb->s_magic = NTFS_SB_MAGIC;
2854        /*
2855         * Ntfs allows 63 bits for the file size, i.e. correct would be:
2856         *      sb->s_maxbytes = ~0ULL >> 1;
2857         * But the kernel uses a long as the page cache page index which on
2858         * 32-bit architectures is only 32-bits. MAX_LFS_FILESIZE is kernel
2859         * defined to the maximum the page cache page index can cope with
2860         * without overflowing the index or to 2^63 - 1, whichever is smaller.
2861         */
2862        sb->s_maxbytes = MAX_LFS_FILESIZE;
2863        /* Ntfs measures time in 100ns intervals. */
2864        sb->s_time_gran = 100;
2865        /*
2866         * Now load the metadata required for the page cache and our address
2867         * space operations to function. We do this by setting up a specialised
2868         * read_inode method and then just calling the normal iget() to obtain
2869         * the inode for $MFT which is sufficient to allow our normal inode
2870         * operations and associated address space operations to function.
2871         */
2872        sb->s_op = &ntfs_sops;
2873        tmp_ino = new_inode(sb);
2874        if (!tmp_ino) {
2875                if (!silent)
2876                        ntfs_error(sb, "Failed to load essential metadata.");
2877                goto err_out_now;
2878        }
2879        tmp_ino->i_ino = FILE_MFT;
2880        insert_inode_hash(tmp_ino);
2881        if (ntfs_read_inode_mount(tmp_ino) < 0) {
2882                if (!silent)
2883                        ntfs_error(sb, "Failed to load essential metadata.");
2884                goto iput_tmp_ino_err_out_now;
2885        }
2886        mutex_lock(&ntfs_lock);
2887        /*
2888         * The current mount is a compression user if the cluster size is
2889         * less than or equal 4kiB.
2890         */
2891        if (vol->cluster_size <= 4096 && !ntfs_nr_compression_users++) {
2892                result = allocate_compression_buffers();
2893                if (result) {
2894                        ntfs_error(NULL, "Failed to allocate buffers "
2895                                        "for compression engine.");
2896                        ntfs_nr_compression_users--;
2897                        mutex_unlock(&ntfs_lock);
2898                        goto iput_tmp_ino_err_out_now;
2899                }
2900        }
2901        /*
2902         * Generate the global default upcase table if necessary.  Also
2903         * temporarily increment the number of upcase users to avoid race
2904         * conditions with concurrent (u)mounts.
2905         */
2906        if (!default_upcase)
2907                default_upcase = generate_default_upcase();
2908        ntfs_nr_upcase_users++;
2909        mutex_unlock(&ntfs_lock);
2910        /*
2911         * From now on, ignore @silent parameter. If we fail below this line,
2912         * it will be due to a corrupt fs or a system error, so we report it.
2913         */
2914        /*
2915         * Open the system files with normal access functions and complete
2916         * setting up the ntfs super block.
2917         */
2918        if (!load_system_files(vol)) {
2919                ntfs_error(sb, "Failed to load system files.");
2920                goto unl_upcase_iput_tmp_ino_err_out_now;
2921        }
2922
2923        /* We grab a reference, simulating an ntfs_iget(). */
2924        ihold(vol->root_ino);
2925        if ((sb->s_root = d_make_root(vol->root_ino))) {
2926                ntfs_debug("Exiting, status successful.");
2927                /* Release the default upcase if it has no users. */
2928                mutex_lock(&ntfs_lock);
2929                if (!--ntfs_nr_upcase_users && default_upcase) {
2930                        ntfs_free(default_upcase);
2931                        default_upcase = NULL;
2932                }
2933                mutex_unlock(&ntfs_lock);
2934                sb->s_export_op = &ntfs_export_ops;
2935                lockdep_on();
2936                return 0;
2937        }
2938        ntfs_error(sb, "Failed to allocate root directory.");
2939        /* Clean up after the successful load_system_files() call from above. */
2940        // TODO: Use ntfs_put_super() instead of repeating all this code...
2941        // FIXME: Should mark the volume clean as the error is most likely
2942        //        -ENOMEM.
2943        iput(vol->vol_ino);
2944        vol->vol_ino = NULL;
2945        /* NTFS 3.0+ specific clean up. */
2946        if (vol->major_ver >= 3) {
2947#ifdef NTFS_RW
2948                if (vol->usnjrnl_j_ino) {
2949                        iput(vol->usnjrnl_j_ino);
2950                        vol->usnjrnl_j_ino = NULL;
2951                }
2952                if (vol->usnjrnl_max_ino) {
2953                        iput(vol->usnjrnl_max_ino);
2954                        vol->usnjrnl_max_ino = NULL;
2955                }
2956                if (vol->usnjrnl_ino) {
2957                        iput(vol->usnjrnl_ino);
2958                        vol->usnjrnl_ino = NULL;
2959                }
2960                if (vol->quota_q_ino) {
2961                        iput(vol->quota_q_ino);
2962                        vol->quota_q_ino = NULL;
2963                }
2964                if (vol->quota_ino) {
2965                        iput(vol->quota_ino);
2966                        vol->quota_ino = NULL;
2967                }
2968#endif /* NTFS_RW */
2969                if (vol->extend_ino) {
2970                        iput(vol->extend_ino);
2971                        vol->extend_ino = NULL;
2972                }
2973                if (vol->secure_ino) {
2974                        iput(vol->secure_ino);
2975                        vol->secure_ino = NULL;
2976                }
2977        }
2978        iput(vol->root_ino);
2979        vol->root_ino = NULL;
2980        iput(vol->lcnbmp_ino);
2981        vol->lcnbmp_ino = NULL;
2982        iput(vol->mftbmp_ino);
2983        vol->mftbmp_ino = NULL;
2984#ifdef NTFS_RW
2985        if (vol->logfile_ino) {
2986                iput(vol->logfile_ino);
2987                vol->logfile_ino = NULL;
2988        }
2989        if (vol->mftmirr_ino) {
2990                iput(vol->mftmirr_ino);
2991                vol->mftmirr_ino = NULL;
2992        }
2993#endif /* NTFS_RW */
2994        /* Throw away the table of attribute definitions. */
2995        vol->attrdef_size = 0;
2996        if (vol->attrdef) {
2997                ntfs_free(vol->attrdef);
2998                vol->attrdef = NULL;
2999        }
3000        vol->upcase_len = 0;
3001        mutex_lock(&ntfs_lock);
3002        if (vol->upcase == default_upcase) {
3003                ntfs_nr_upcase_users--;
3004                vol->upcase = NULL;
3005        }
3006        mutex_unlock(&ntfs_lock);
3007        if (vol->upcase) {
3008                ntfs_free(vol->upcase);
3009                vol->upcase = NULL;
3010        }
3011        if (vol->nls_map) {
3012                unload_nls(vol->nls_map);
3013                vol->nls_map = NULL;
3014        }
3015        /* Error exit code path. */
3016unl_upcase_iput_tmp_ino_err_out_now:
3017        /*
3018         * Decrease the number of upcase users and destroy the global default
3019         * upcase table if necessary.
3020         */
3021        mutex_lock(&ntfs_lock);
3022        if (!--ntfs_nr_upcase_users && default_upcase) {
3023                ntfs_free(default_upcase);
3024                default_upcase = NULL;
3025        }
3026        if (vol->cluster_size <= 4096 && !--ntfs_nr_compression_users)
3027                free_compression_buffers();
3028        mutex_unlock(&ntfs_lock);
3029iput_tmp_ino_err_out_now:
3030        iput(tmp_ino);
3031        if (vol->mft_ino && vol->mft_ino != tmp_ino)
3032                iput(vol->mft_ino);
3033        vol->mft_ino = NULL;
3034        /* Errors at this stage are irrelevant. */
3035err_out_now:
3036        sb->s_fs_info = NULL;
3037        kfree(vol);
3038        ntfs_debug("Failed, returning -EINVAL.");
3039        lockdep_on();
3040        return -EINVAL;
3041}
3042
3043/*
3044 * This is a slab cache to optimize allocations and deallocations of Unicode
3045 * strings of the maximum length allowed by NTFS, which is NTFS_MAX_NAME_LEN
3046 * (255) Unicode characters + a terminating NULL Unicode character.
3047 */
3048struct kmem_cache *ntfs_name_cache;
3049
3050/* Slab caches for efficient allocation/deallocation of inodes. */
3051struct kmem_cache *ntfs_inode_cache;
3052struct kmem_cache *ntfs_big_inode_cache;
3053
3054/* Init once constructor for the inode slab cache. */
3055static void ntfs_big_inode_init_once(void *foo)
3056{
3057        ntfs_inode *ni = (ntfs_inode *)foo;
3058
3059        inode_init_once(VFS_I(ni));
3060}
3061
3062/*
3063 * Slab caches to optimize allocations and deallocations of attribute search
3064 * contexts and index contexts, respectively.
3065 */
3066struct kmem_cache *ntfs_attr_ctx_cache;
3067struct kmem_cache *ntfs_index_ctx_cache;
3068
3069/* Driver wide mutex. */
3070DEFINE_MUTEX(ntfs_lock);
3071
3072static struct dentry *ntfs_mount(struct file_system_type *fs_type,
3073        int flags, const char *dev_name, void *data)
3074{
3075        return mount_bdev(fs_type, flags, dev_name, data, ntfs_fill_super);
3076}
3077
3078static struct file_system_type ntfs_fs_type = {
3079        .owner          = THIS_MODULE,
3080        .name           = "ntfs",
3081        .mount          = ntfs_mount,
3082        .kill_sb        = kill_block_super,
3083        .fs_flags       = FS_REQUIRES_DEV,
3084};
3085MODULE_ALIAS_FS("ntfs");
3086
3087/* Stable names for the slab caches. */
3088static const char ntfs_index_ctx_cache_name[] = "ntfs_index_ctx_cache";
3089static const char ntfs_attr_ctx_cache_name[] = "ntfs_attr_ctx_cache";
3090static const char ntfs_name_cache_name[] = "ntfs_name_cache";
3091static const char ntfs_inode_cache_name[] = "ntfs_inode_cache";
3092static const char ntfs_big_inode_cache_name[] = "ntfs_big_inode_cache";
3093
3094static int __init init_ntfs_fs(void)
3095{
3096        int err = 0;
3097
3098        /* This may be ugly but it results in pretty output so who cares. (-8 */
3099        pr_info("driver " NTFS_VERSION " [Flags: R/"
3100#ifdef NTFS_RW
3101                        "W"
3102#else
3103                        "O"
3104#endif
3105#ifdef DEBUG
3106                        " DEBUG"
3107#endif
3108#ifdef MODULE
3109                        " MODULE"
3110#endif
3111                        "].\n");
3112
3113        ntfs_debug("Debug messages are enabled.");
3114
3115        ntfs_index_ctx_cache = kmem_cache_create(ntfs_index_ctx_cache_name,
3116                        sizeof(ntfs_index_context), 0 /* offset */,
3117                        SLAB_HWCACHE_ALIGN, NULL /* ctor */);
3118        if (!ntfs_index_ctx_cache) {
3119                pr_crit("Failed to create %s!\n", ntfs_index_ctx_cache_name);
3120                goto ictx_err_out;
3121        }
3122        ntfs_attr_ctx_cache = kmem_cache_create(ntfs_attr_ctx_cache_name,
3123                        sizeof(ntfs_attr_search_ctx), 0 /* offset */,
3124                        SLAB_HWCACHE_ALIGN, NULL /* ctor */);
3125        if (!ntfs_attr_ctx_cache) {
3126                pr_crit("NTFS: Failed to create %s!\n",
3127                        ntfs_attr_ctx_cache_name);
3128                goto actx_err_out;
3129        }
3130
3131        ntfs_name_cache = kmem_cache_create(ntfs_name_cache_name,
3132                        (NTFS_MAX_NAME_LEN+1) * sizeof(ntfschar), 0,
3133                        SLAB_HWCACHE_ALIGN, NULL);
3134        if (!ntfs_name_cache) {
3135                pr_crit("Failed to create %s!\n", ntfs_name_cache_name);
3136                goto name_err_out;
3137        }
3138
3139        ntfs_inode_cache = kmem_cache_create(ntfs_inode_cache_name,
3140                        sizeof(ntfs_inode), 0,
3141                        SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL);
3142        if (!ntfs_inode_cache) {
3143                pr_crit("Failed to create %s!\n", ntfs_inode_cache_name);
3144                goto inode_err_out;
3145        }
3146
3147        ntfs_big_inode_cache = kmem_cache_create(ntfs_big_inode_cache_name,
3148                        sizeof(big_ntfs_inode), 0,
3149                        SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
3150                        ntfs_big_inode_init_once);
3151        if (!ntfs_big_inode_cache) {
3152                pr_crit("Failed to create %s!\n", ntfs_big_inode_cache_name);
3153                goto big_inode_err_out;
3154        }
3155
3156        /* Register the ntfs sysctls. */
3157        err = ntfs_sysctl(1);
3158        if (err) {
3159                pr_crit("Failed to register NTFS sysctls!\n");
3160                goto sysctl_err_out;
3161        }
3162
3163        err = register_filesystem(&ntfs_fs_type);
3164        if (!err) {
3165                ntfs_debug("NTFS driver registered successfully.");
3166                return 0; /* Success! */
3167        }
3168        pr_crit("Failed to register NTFS filesystem driver!\n");
3169
3170        /* Unregister the ntfs sysctls. */
3171        ntfs_sysctl(0);
3172sysctl_err_out:
3173        kmem_cache_destroy(ntfs_big_inode_cache);
3174big_inode_err_out:
3175        kmem_cache_destroy(ntfs_inode_cache);
3176inode_err_out:
3177        kmem_cache_destroy(ntfs_name_cache);
3178name_err_out:
3179        kmem_cache_destroy(ntfs_attr_ctx_cache);
3180actx_err_out:
3181        kmem_cache_destroy(ntfs_index_ctx_cache);
3182ictx_err_out:
3183        if (!err) {
3184                pr_crit("Aborting NTFS filesystem driver registration...\n");
3185                err = -ENOMEM;
3186        }
3187        return err;
3188}
3189
3190static void __exit exit_ntfs_fs(void)
3191{
3192        ntfs_debug("Unregistering NTFS driver.");
3193
3194        unregister_filesystem(&ntfs_fs_type);
3195
3196        /*
3197         * Make sure all delayed rcu free inodes are flushed before we
3198         * destroy cache.
3199         */
3200        rcu_barrier();
3201        kmem_cache_destroy(ntfs_big_inode_cache);
3202        kmem_cache_destroy(ntfs_inode_cache);
3203        kmem_cache_destroy(ntfs_name_cache);
3204        kmem_cache_destroy(ntfs_attr_ctx_cache);
3205        kmem_cache_destroy(ntfs_index_ctx_cache);
3206        /* Unregister the ntfs sysctls. */
3207        ntfs_sysctl(0);
3208}
3209
3210MODULE_AUTHOR("Anton Altaparmakov <anton@tuxera.com>");
3211MODULE_DESCRIPTION("NTFS 1.2/3.x driver - Copyright (c) 2001-2014 Anton Altaparmakov and Tuxera Inc.");
3212MODULE_VERSION(NTFS_VERSION);
3213MODULE_LICENSE("GPL");
3214#ifdef DEBUG
3215module_param(debug_msgs, bint, 0);
3216MODULE_PARM_DESC(debug_msgs, "Enable debug messages.");
3217#endif
3218
3219module_init(init_ntfs_fs)
3220module_exit(exit_ntfs_fs)
3221