linux/fs/udf/super.c
<<
>>
Prefs
   1/*
   2 * super.c
   3 *
   4 * PURPOSE
   5 *  Super block routines for the OSTA-UDF(tm) filesystem.
   6 *
   7 * DESCRIPTION
   8 *  OSTA-UDF(tm) = Optical Storage Technology Association
   9 *  Universal Disk Format.
  10 *
  11 *  This code is based on version 2.00 of the UDF specification,
  12 *  and revision 3 of the ECMA 167 standard [equivalent to ISO 13346].
  13 *    http://www.osta.org/
  14 *    http://www.ecma.ch/
  15 *    http://www.iso.org/
  16 *
  17 * COPYRIGHT
  18 *  This file is distributed under the terms of the GNU General Public
  19 *  License (GPL). Copies of the GPL can be obtained from:
  20 *    ftp://prep.ai.mit.edu/pub/gnu/GPL
  21 *  Each contributing author retains all rights to their own work.
  22 *
  23 *  (C) 1998 Dave Boynton
  24 *  (C) 1998-2004 Ben Fennema
  25 *  (C) 2000 Stelias Computing Inc
  26 *
  27 * HISTORY
  28 *
  29 *  09/24/98 dgb  changed to allow compiling outside of kernel, and
  30 *                added some debugging.
  31 *  10/01/98 dgb  updated to allow (some) possibility of compiling w/2.0.34
  32 *  10/16/98      attempting some multi-session support
  33 *  10/17/98      added freespace count for "df"
  34 *  11/11/98 gr   added novrs option
  35 *  11/26/98 dgb  added fileset,anchor mount options
  36 *  12/06/98 blf  really hosed things royally. vat/sparing support. sequenced
  37 *                vol descs. rewrote option handling based on isofs
  38 *  12/20/98      find the free space bitmap (if it exists)
  39 */
  40
  41#include "udfdecl.h"
  42
  43#include <linux/blkdev.h>
  44#include <linux/slab.h>
  45#include <linux/kernel.h>
  46#include <linux/module.h>
  47#include <linux/parser.h>
  48#include <linux/stat.h>
  49#include <linux/cdrom.h>
  50#include <linux/nls.h>
  51#include <linux/buffer_head.h>
  52#include <linux/vfs.h>
  53#include <linux/vmalloc.h>
  54#include <linux/errno.h>
  55#include <linux/mount.h>
  56#include <linux/seq_file.h>
  57#include <linux/bitmap.h>
  58#include <linux/crc-itu-t.h>
  59#include <linux/log2.h>
  60#include <asm/byteorder.h>
  61
  62#include "udf_sb.h"
  63#include "udf_i.h"
  64
  65#include <linux/init.h>
  66#include <asm/uaccess.h>
  67
  68#define VDS_POS_PRIMARY_VOL_DESC        0
  69#define VDS_POS_UNALLOC_SPACE_DESC      1
  70#define VDS_POS_LOGICAL_VOL_DESC        2
  71#define VDS_POS_PARTITION_DESC          3
  72#define VDS_POS_IMP_USE_VOL_DESC        4
  73#define VDS_POS_VOL_DESC_PTR            5
  74#define VDS_POS_TERMINATING_DESC        6
  75#define VDS_POS_LENGTH                  7
  76
  77#define UDF_DEFAULT_BLOCKSIZE 2048
  78
  79enum { UDF_MAX_LINKS = 0xffff };
  80
  81/* These are the "meat" - everything else is stuffing */
  82static int udf_fill_super(struct super_block *, void *, int);
  83static void udf_put_super(struct super_block *);
  84static int udf_sync_fs(struct super_block *, int);
  85static int udf_remount_fs(struct super_block *, int *, char *);
  86static void udf_load_logicalvolint(struct super_block *, struct kernel_extent_ad);
  87static int udf_find_fileset(struct super_block *, struct kernel_lb_addr *,
  88                            struct kernel_lb_addr *);
  89static void udf_load_fileset(struct super_block *, struct buffer_head *,
  90                             struct kernel_lb_addr *);
  91static void udf_open_lvid(struct super_block *);
  92static void udf_close_lvid(struct super_block *);
  93static unsigned int udf_count_free(struct super_block *);
  94static int udf_statfs(struct dentry *, struct kstatfs *);
  95static int udf_show_options(struct seq_file *, struct dentry *);
  96
  97struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
  98{
  99        struct logicalVolIntegrityDesc *lvid =
 100                (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
 101        __u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
 102        __u32 offset = number_of_partitions * 2 *
 103                                sizeof(uint32_t)/sizeof(uint8_t);
 104        return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
 105}
 106
 107/* UDF filesystem type */
 108static struct dentry *udf_mount(struct file_system_type *fs_type,
 109                      int flags, const char *dev_name, void *data)
 110{
 111        return mount_bdev(fs_type, flags, dev_name, data, udf_fill_super);
 112}
 113
 114static struct file_system_type udf_fstype = {
 115        .owner          = THIS_MODULE,
 116        .name           = "udf",
 117        .mount          = udf_mount,
 118        .kill_sb        = kill_block_super,
 119        .fs_flags       = FS_REQUIRES_DEV,
 120};
 121MODULE_ALIAS_FS("udf");
 122
 123static struct kmem_cache *udf_inode_cachep;
 124
 125static struct inode *udf_alloc_inode(struct super_block *sb)
 126{
 127        struct udf_inode_info *ei;
 128        ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
 129        if (!ei)
 130                return NULL;
 131
 132        ei->i_unique = 0;
 133        ei->i_lenExtents = 0;
 134        ei->i_next_alloc_block = 0;
 135        ei->i_next_alloc_goal = 0;
 136        ei->i_strat4096 = 0;
 137        init_rwsem(&ei->i_data_sem);
 138        ei->cached_extent.lstart = -1;
 139        spin_lock_init(&ei->i_extent_cache_lock);
 140
 141        return &ei->vfs_inode;
 142}
 143
 144static void udf_i_callback(struct rcu_head *head)
 145{
 146        struct inode *inode = container_of(head, struct inode, i_rcu);
 147        kmem_cache_free(udf_inode_cachep, UDF_I(inode));
 148}
 149
 150static void udf_destroy_inode(struct inode *inode)
 151{
 152        call_rcu(&inode->i_rcu, udf_i_callback);
 153}
 154
 155static void init_once(void *foo)
 156{
 157        struct udf_inode_info *ei = (struct udf_inode_info *)foo;
 158
 159        ei->i_ext.i_data = NULL;
 160        inode_init_once(&ei->vfs_inode);
 161}
 162
 163static int init_inodecache(void)
 164{
 165        udf_inode_cachep = kmem_cache_create("udf_inode_cache",
 166                                             sizeof(struct udf_inode_info),
 167                                             0, (SLAB_RECLAIM_ACCOUNT |
 168                                                 SLAB_MEM_SPREAD),
 169                                             init_once);
 170        if (!udf_inode_cachep)
 171                return -ENOMEM;
 172        return 0;
 173}
 174
 175static void destroy_inodecache(void)
 176{
 177        /*
 178         * Make sure all delayed rcu free inodes are flushed before we
 179         * destroy cache.
 180         */
 181        rcu_barrier();
 182        kmem_cache_destroy(udf_inode_cachep);
 183}
 184
 185/* Superblock operations */
 186static const struct super_operations udf_sb_ops = {
 187        .alloc_inode    = udf_alloc_inode,
 188        .destroy_inode  = udf_destroy_inode,
 189        .write_inode    = udf_write_inode,
 190        .evict_inode    = udf_evict_inode,
 191        .put_super      = udf_put_super,
 192        .sync_fs        = udf_sync_fs,
 193        .statfs         = udf_statfs,
 194        .remount_fs     = udf_remount_fs,
 195        .show_options   = udf_show_options,
 196};
 197
 198struct udf_options {
 199        unsigned char novrs;
 200        unsigned int blocksize;
 201        unsigned int session;
 202        unsigned int lastblock;
 203        unsigned int anchor;
 204        unsigned int volume;
 205        unsigned short partition;
 206        unsigned int fileset;
 207        unsigned int rootdir;
 208        unsigned int flags;
 209        umode_t umask;
 210        kgid_t gid;
 211        kuid_t uid;
 212        umode_t fmode;
 213        umode_t dmode;
 214        struct nls_table *nls_map;
 215};
 216
 217static int __init init_udf_fs(void)
 218{
 219        int err;
 220
 221        err = init_inodecache();
 222        if (err)
 223                goto out1;
 224        err = register_filesystem(&udf_fstype);
 225        if (err)
 226                goto out;
 227
 228        return 0;
 229
 230out:
 231        destroy_inodecache();
 232
 233out1:
 234        return err;
 235}
 236
 237static void __exit exit_udf_fs(void)
 238{
 239        unregister_filesystem(&udf_fstype);
 240        destroy_inodecache();
 241}
 242
 243module_init(init_udf_fs)
 244module_exit(exit_udf_fs)
 245
 246static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
 247{
 248        struct udf_sb_info *sbi = UDF_SB(sb);
 249
 250        sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
 251                                  GFP_KERNEL);
 252        if (!sbi->s_partmaps) {
 253                udf_err(sb, "Unable to allocate space for %d partition maps\n",
 254                        count);
 255                sbi->s_partitions = 0;
 256                return -ENOMEM;
 257        }
 258
 259        sbi->s_partitions = count;
 260        return 0;
 261}
 262
 263static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
 264{
 265        int i;
 266        int nr_groups = bitmap->s_nr_groups;
 267        int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
 268                                                nr_groups);
 269
 270        for (i = 0; i < nr_groups; i++)
 271                if (bitmap->s_block_bitmap[i])
 272                        brelse(bitmap->s_block_bitmap[i]);
 273
 274        if (size <= PAGE_SIZE)
 275                kfree(bitmap);
 276        else
 277                vfree(bitmap);
 278}
 279
 280static void udf_free_partition(struct udf_part_map *map)
 281{
 282        int i;
 283        struct udf_meta_data *mdata;
 284
 285        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
 286                iput(map->s_uspace.s_table);
 287        if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
 288                iput(map->s_fspace.s_table);
 289        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
 290                udf_sb_free_bitmap(map->s_uspace.s_bitmap);
 291        if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
 292                udf_sb_free_bitmap(map->s_fspace.s_bitmap);
 293        if (map->s_partition_type == UDF_SPARABLE_MAP15)
 294                for (i = 0; i < 4; i++)
 295                        brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
 296        else if (map->s_partition_type == UDF_METADATA_MAP25) {
 297                mdata = &map->s_type_specific.s_metadata;
 298                iput(mdata->s_metadata_fe);
 299                mdata->s_metadata_fe = NULL;
 300
 301                iput(mdata->s_mirror_fe);
 302                mdata->s_mirror_fe = NULL;
 303
 304                iput(mdata->s_bitmap_fe);
 305                mdata->s_bitmap_fe = NULL;
 306        }
 307}
 308
 309static void udf_sb_free_partitions(struct super_block *sb)
 310{
 311        struct udf_sb_info *sbi = UDF_SB(sb);
 312        int i;
 313        if (sbi->s_partmaps == NULL)
 314                return;
 315        for (i = 0; i < sbi->s_partitions; i++)
 316                udf_free_partition(&sbi->s_partmaps[i]);
 317        kfree(sbi->s_partmaps);
 318        sbi->s_partmaps = NULL;
 319}
 320
 321static int udf_show_options(struct seq_file *seq, struct dentry *root)
 322{
 323        struct super_block *sb = root->d_sb;
 324        struct udf_sb_info *sbi = UDF_SB(sb);
 325
 326        if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
 327                seq_puts(seq, ",nostrict");
 328        if (UDF_QUERY_FLAG(sb, UDF_FLAG_BLOCKSIZE_SET))
 329                seq_printf(seq, ",bs=%lu", sb->s_blocksize);
 330        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE))
 331                seq_puts(seq, ",unhide");
 332        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE))
 333                seq_puts(seq, ",undelete");
 334        if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB))
 335                seq_puts(seq, ",noadinicb");
 336        if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD))
 337                seq_puts(seq, ",shortad");
 338        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET))
 339                seq_puts(seq, ",uid=forget");
 340        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_IGNORE))
 341                seq_puts(seq, ",uid=ignore");
 342        if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET))
 343                seq_puts(seq, ",gid=forget");
 344        if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_IGNORE))
 345                seq_puts(seq, ",gid=ignore");
 346        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET))
 347                seq_printf(seq, ",uid=%u", from_kuid(&init_user_ns, sbi->s_uid));
 348        if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
 349                seq_printf(seq, ",gid=%u", from_kgid(&init_user_ns, sbi->s_gid));
 350        if (sbi->s_umask != 0)
 351                seq_printf(seq, ",umask=%ho", sbi->s_umask);
 352        if (sbi->s_fmode != UDF_INVALID_MODE)
 353                seq_printf(seq, ",mode=%ho", sbi->s_fmode);
 354        if (sbi->s_dmode != UDF_INVALID_MODE)
 355                seq_printf(seq, ",dmode=%ho", sbi->s_dmode);
 356        if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
 357                seq_printf(seq, ",session=%u", sbi->s_session);
 358        if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
 359                seq_printf(seq, ",lastblock=%u", sbi->s_last_block);
 360        if (sbi->s_anchor != 0)
 361                seq_printf(seq, ",anchor=%u", sbi->s_anchor);
 362        /*
 363         * volume, partition, fileset and rootdir seem to be ignored
 364         * currently
 365         */
 366        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
 367                seq_puts(seq, ",utf8");
 368        if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP) && sbi->s_nls_map)
 369                seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset);
 370
 371        return 0;
 372}
 373
 374/*
 375 * udf_parse_options
 376 *
 377 * PURPOSE
 378 *      Parse mount options.
 379 *
 380 * DESCRIPTION
 381 *      The following mount options are supported:
 382 *
 383 *      gid=            Set the default group.
 384 *      umask=          Set the default umask.
 385 *      mode=           Set the default file permissions.
 386 *      dmode=          Set the default directory permissions.
 387 *      uid=            Set the default user.
 388 *      bs=             Set the block size.
 389 *      unhide          Show otherwise hidden files.
 390 *      undelete        Show deleted files in lists.
 391 *      adinicb         Embed data in the inode (default)
 392 *      noadinicb       Don't embed data in the inode
 393 *      shortad         Use short ad's
 394 *      longad          Use long ad's (default)
 395 *      nostrict        Unset strict conformance
 396 *      iocharset=      Set the NLS character set
 397 *
 398 *      The remaining are for debugging and disaster recovery:
 399 *
 400 *      novrs           Skip volume sequence recognition
 401 *
 402 *      The following expect a offset from 0.
 403 *
 404 *      session=        Set the CDROM session (default= last session)
 405 *      anchor=         Override standard anchor location. (default= 256)
 406 *      volume=         Override the VolumeDesc location. (unused)
 407 *      partition=      Override the PartitionDesc location. (unused)
 408 *      lastblock=      Set the last block of the filesystem/
 409 *
 410 *      The following expect a offset from the partition root.
 411 *
 412 *      fileset=        Override the fileset block location. (unused)
 413 *      rootdir=        Override the root directory location. (unused)
 414 *              WARNING: overriding the rootdir to a non-directory may
 415 *              yield highly unpredictable results.
 416 *
 417 * PRE-CONDITIONS
 418 *      options         Pointer to mount options string.
 419 *      uopts           Pointer to mount options variable.
 420 *
 421 * POST-CONDITIONS
 422 *      <return>        1       Mount options parsed okay.
 423 *      <return>        0       Error parsing mount options.
 424 *
 425 * HISTORY
 426 *      July 1, 1997 - Andrew E. Mileski
 427 *      Written, tested, and released.
 428 */
 429
 430enum {
 431        Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete,
 432        Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad,
 433        Opt_gid, Opt_uid, Opt_umask, Opt_session, Opt_lastblock,
 434        Opt_anchor, Opt_volume, Opt_partition, Opt_fileset,
 435        Opt_rootdir, Opt_utf8, Opt_iocharset,
 436        Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore,
 437        Opt_fmode, Opt_dmode
 438};
 439
 440static const match_table_t tokens = {
 441        {Opt_novrs,     "novrs"},
 442        {Opt_nostrict,  "nostrict"},
 443        {Opt_bs,        "bs=%u"},
 444        {Opt_unhide,    "unhide"},
 445        {Opt_undelete,  "undelete"},
 446        {Opt_noadinicb, "noadinicb"},
 447        {Opt_adinicb,   "adinicb"},
 448        {Opt_shortad,   "shortad"},
 449        {Opt_longad,    "longad"},
 450        {Opt_uforget,   "uid=forget"},
 451        {Opt_uignore,   "uid=ignore"},
 452        {Opt_gforget,   "gid=forget"},
 453        {Opt_gignore,   "gid=ignore"},
 454        {Opt_gid,       "gid=%u"},
 455        {Opt_uid,       "uid=%u"},
 456        {Opt_umask,     "umask=%o"},
 457        {Opt_session,   "session=%u"},
 458        {Opt_lastblock, "lastblock=%u"},
 459        {Opt_anchor,    "anchor=%u"},
 460        {Opt_volume,    "volume=%u"},
 461        {Opt_partition, "partition=%u"},
 462        {Opt_fileset,   "fileset=%u"},
 463        {Opt_rootdir,   "rootdir=%u"},
 464        {Opt_utf8,      "utf8"},
 465        {Opt_iocharset, "iocharset=%s"},
 466        {Opt_fmode,     "mode=%o"},
 467        {Opt_dmode,     "dmode=%o"},
 468        {Opt_err,       NULL}
 469};
 470
 471static int udf_parse_options(char *options, struct udf_options *uopt,
 472                             bool remount)
 473{
 474        char *p;
 475        int option;
 476
 477        uopt->novrs = 0;
 478        uopt->partition = 0xFFFF;
 479        uopt->session = 0xFFFFFFFF;
 480        uopt->lastblock = 0;
 481        uopt->anchor = 0;
 482        uopt->volume = 0xFFFFFFFF;
 483        uopt->rootdir = 0xFFFFFFFF;
 484        uopt->fileset = 0xFFFFFFFF;
 485        uopt->nls_map = NULL;
 486
 487        if (!options)
 488                return 1;
 489
 490        while ((p = strsep(&options, ",")) != NULL) {
 491                substring_t args[MAX_OPT_ARGS];
 492                int token;
 493                if (!*p)
 494                        continue;
 495
 496                token = match_token(p, tokens, args);
 497                switch (token) {
 498                case Opt_novrs:
 499                        uopt->novrs = 1;
 500                        break;
 501                case Opt_bs:
 502                        if (match_int(&args[0], &option))
 503                                return 0;
 504                        uopt->blocksize = option;
 505                        uopt->flags |= (1 << UDF_FLAG_BLOCKSIZE_SET);
 506                        break;
 507                case Opt_unhide:
 508                        uopt->flags |= (1 << UDF_FLAG_UNHIDE);
 509                        break;
 510                case Opt_undelete:
 511                        uopt->flags |= (1 << UDF_FLAG_UNDELETE);
 512                        break;
 513                case Opt_noadinicb:
 514                        uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB);
 515                        break;
 516                case Opt_adinicb:
 517                        uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB);
 518                        break;
 519                case Opt_shortad:
 520                        uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD);
 521                        break;
 522                case Opt_longad:
 523                        uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD);
 524                        break;
 525                case Opt_gid:
 526                        if (match_int(args, &option))
 527                                return 0;
 528                        uopt->gid = make_kgid(current_user_ns(), option);
 529                        if (!gid_valid(uopt->gid))
 530                                return 0;
 531                        uopt->flags |= (1 << UDF_FLAG_GID_SET);
 532                        break;
 533                case Opt_uid:
 534                        if (match_int(args, &option))
 535                                return 0;
 536                        uopt->uid = make_kuid(current_user_ns(), option);
 537                        if (!uid_valid(uopt->uid))
 538                                return 0;
 539                        uopt->flags |= (1 << UDF_FLAG_UID_SET);
 540                        break;
 541                case Opt_umask:
 542                        if (match_octal(args, &option))
 543                                return 0;
 544                        uopt->umask = option;
 545                        break;
 546                case Opt_nostrict:
 547                        uopt->flags &= ~(1 << UDF_FLAG_STRICT);
 548                        break;
 549                case Opt_session:
 550                        if (match_int(args, &option))
 551                                return 0;
 552                        uopt->session = option;
 553                        if (!remount)
 554                                uopt->flags |= (1 << UDF_FLAG_SESSION_SET);
 555                        break;
 556                case Opt_lastblock:
 557                        if (match_int(args, &option))
 558                                return 0;
 559                        uopt->lastblock = option;
 560                        if (!remount)
 561                                uopt->flags |= (1 << UDF_FLAG_LASTBLOCK_SET);
 562                        break;
 563                case Opt_anchor:
 564                        if (match_int(args, &option))
 565                                return 0;
 566                        uopt->anchor = option;
 567                        break;
 568                case Opt_volume:
 569                        if (match_int(args, &option))
 570                                return 0;
 571                        uopt->volume = option;
 572                        break;
 573                case Opt_partition:
 574                        if (match_int(args, &option))
 575                                return 0;
 576                        uopt->partition = option;
 577                        break;
 578                case Opt_fileset:
 579                        if (match_int(args, &option))
 580                                return 0;
 581                        uopt->fileset = option;
 582                        break;
 583                case Opt_rootdir:
 584                        if (match_int(args, &option))
 585                                return 0;
 586                        uopt->rootdir = option;
 587                        break;
 588                case Opt_utf8:
 589                        uopt->flags |= (1 << UDF_FLAG_UTF8);
 590                        break;
 591#ifdef CONFIG_UDF_NLS
 592                case Opt_iocharset:
 593                        uopt->nls_map = load_nls(args[0].from);
 594                        uopt->flags |= (1 << UDF_FLAG_NLS_MAP);
 595                        break;
 596#endif
 597                case Opt_uignore:
 598                        uopt->flags |= (1 << UDF_FLAG_UID_IGNORE);
 599                        break;
 600                case Opt_uforget:
 601                        uopt->flags |= (1 << UDF_FLAG_UID_FORGET);
 602                        break;
 603                case Opt_gignore:
 604                        uopt->flags |= (1 << UDF_FLAG_GID_IGNORE);
 605                        break;
 606                case Opt_gforget:
 607                        uopt->flags |= (1 << UDF_FLAG_GID_FORGET);
 608                        break;
 609                case Opt_fmode:
 610                        if (match_octal(args, &option))
 611                                return 0;
 612                        uopt->fmode = option & 0777;
 613                        break;
 614                case Opt_dmode:
 615                        if (match_octal(args, &option))
 616                                return 0;
 617                        uopt->dmode = option & 0777;
 618                        break;
 619                default:
 620                        pr_err("bad mount option \"%s\" or missing value\n", p);
 621                        return 0;
 622                }
 623        }
 624        return 1;
 625}
 626
 627static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
 628{
 629        struct udf_options uopt;
 630        struct udf_sb_info *sbi = UDF_SB(sb);
 631        int error = 0;
 632
 633        uopt.flags = sbi->s_flags;
 634        uopt.uid   = sbi->s_uid;
 635        uopt.gid   = sbi->s_gid;
 636        uopt.umask = sbi->s_umask;
 637        uopt.fmode = sbi->s_fmode;
 638        uopt.dmode = sbi->s_dmode;
 639
 640        if (!udf_parse_options(options, &uopt, true))
 641                return -EINVAL;
 642
 643        write_lock(&sbi->s_cred_lock);
 644        sbi->s_flags = uopt.flags;
 645        sbi->s_uid   = uopt.uid;
 646        sbi->s_gid   = uopt.gid;
 647        sbi->s_umask = uopt.umask;
 648        sbi->s_fmode = uopt.fmode;
 649        sbi->s_dmode = uopt.dmode;
 650        write_unlock(&sbi->s_cred_lock);
 651
 652        if (sbi->s_lvid_bh) {
 653                int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev);
 654                if (write_rev > UDF_MAX_WRITE_VERSION)
 655                        *flags |= MS_RDONLY;
 656        }
 657
 658        if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
 659                goto out_unlock;
 660
 661        if (*flags & MS_RDONLY)
 662                udf_close_lvid(sb);
 663        else
 664                udf_open_lvid(sb);
 665
 666out_unlock:
 667        return error;
 668}
 669
 670/* Check Volume Structure Descriptors (ECMA 167 2/9.1) */
 671/* We also check any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
 672static loff_t udf_check_vsd(struct super_block *sb)
 673{
 674        struct volStructDesc *vsd = NULL;
 675        loff_t sector = 32768;
 676        int sectorsize;
 677        struct buffer_head *bh = NULL;
 678        int nsr02 = 0;
 679        int nsr03 = 0;
 680        struct udf_sb_info *sbi;
 681
 682        sbi = UDF_SB(sb);
 683        if (sb->s_blocksize < sizeof(struct volStructDesc))
 684                sectorsize = sizeof(struct volStructDesc);
 685        else
 686                sectorsize = sb->s_blocksize;
 687
 688        sector += (sbi->s_session << sb->s_blocksize_bits);
 689
 690        udf_debug("Starting at sector %u (%ld byte sectors)\n",
 691                  (unsigned int)(sector >> sb->s_blocksize_bits),
 692                  sb->s_blocksize);
 693        /* Process the sequence (if applicable) */
 694        for (; !nsr02 && !nsr03; sector += sectorsize) {
 695                /* Read a block */
 696                bh = udf_tread(sb, sector >> sb->s_blocksize_bits);
 697                if (!bh)
 698                        break;
 699
 700                /* Look for ISO  descriptors */
 701                vsd = (struct volStructDesc *)(bh->b_data +
 702                                              (sector & (sb->s_blocksize - 1)));
 703
 704                if (vsd->stdIdent[0] == 0) {
 705                        brelse(bh);
 706                        break;
 707                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
 708                                    VSD_STD_ID_LEN)) {
 709                        switch (vsd->structType) {
 710                        case 0:
 711                                udf_debug("ISO9660 Boot Record found\n");
 712                                break;
 713                        case 1:
 714                                udf_debug("ISO9660 Primary Volume Descriptor found\n");
 715                                break;
 716                        case 2:
 717                                udf_debug("ISO9660 Supplementary Volume Descriptor found\n");
 718                                break;
 719                        case 3:
 720                                udf_debug("ISO9660 Volume Partition Descriptor found\n");
 721                                break;
 722                        case 255:
 723                                udf_debug("ISO9660 Volume Descriptor Set Terminator found\n");
 724                                break;
 725                        default:
 726                                udf_debug("ISO9660 VRS (%u) found\n",
 727                                          vsd->structType);
 728                                break;
 729                        }
 730                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01,
 731                                    VSD_STD_ID_LEN))
 732                        ; /* nothing */
 733                else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01,
 734                                    VSD_STD_ID_LEN)) {
 735                        brelse(bh);
 736                        break;
 737                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
 738                                    VSD_STD_ID_LEN))
 739                        nsr02 = sector;
 740                else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
 741                                    VSD_STD_ID_LEN))
 742                        nsr03 = sector;
 743                brelse(bh);
 744        }
 745
 746        if (nsr03)
 747                return nsr03;
 748        else if (nsr02)
 749                return nsr02;
 750        else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768)
 751                return -1;
 752        else
 753                return 0;
 754}
 755
 756static int udf_find_fileset(struct super_block *sb,
 757                            struct kernel_lb_addr *fileset,
 758                            struct kernel_lb_addr *root)
 759{
 760        struct buffer_head *bh = NULL;
 761        long lastblock;
 762        uint16_t ident;
 763        struct udf_sb_info *sbi;
 764
 765        if (fileset->logicalBlockNum != 0xFFFFFFFF ||
 766            fileset->partitionReferenceNum != 0xFFFF) {
 767                bh = udf_read_ptagged(sb, fileset, 0, &ident);
 768
 769                if (!bh) {
 770                        return 1;
 771                } else if (ident != TAG_IDENT_FSD) {
 772                        brelse(bh);
 773                        return 1;
 774                }
 775
 776        }
 777
 778        sbi = UDF_SB(sb);
 779        if (!bh) {
 780                /* Search backwards through the partitions */
 781                struct kernel_lb_addr newfileset;
 782
 783/* --> cvg: FIXME - is it reasonable? */
 784                return 1;
 785
 786                for (newfileset.partitionReferenceNum = sbi->s_partitions - 1;
 787                     (newfileset.partitionReferenceNum != 0xFFFF &&
 788                      fileset->logicalBlockNum == 0xFFFFFFFF &&
 789                      fileset->partitionReferenceNum == 0xFFFF);
 790                     newfileset.partitionReferenceNum--) {
 791                        lastblock = sbi->s_partmaps
 792                                        [newfileset.partitionReferenceNum]
 793                                                .s_partition_len;
 794                        newfileset.logicalBlockNum = 0;
 795
 796                        do {
 797                                bh = udf_read_ptagged(sb, &newfileset, 0,
 798                                                      &ident);
 799                                if (!bh) {
 800                                        newfileset.logicalBlockNum++;
 801                                        continue;
 802                                }
 803
 804                                switch (ident) {
 805                                case TAG_IDENT_SBD:
 806                                {
 807                                        struct spaceBitmapDesc *sp;
 808                                        sp = (struct spaceBitmapDesc *)
 809                                                                bh->b_data;
 810                                        newfileset.logicalBlockNum += 1 +
 811                                                ((le32_to_cpu(sp->numOfBytes) +
 812                                                  sizeof(struct spaceBitmapDesc)
 813                                                  - 1) >> sb->s_blocksize_bits);
 814                                        brelse(bh);
 815                                        break;
 816                                }
 817                                case TAG_IDENT_FSD:
 818                                        *fileset = newfileset;
 819                                        break;
 820                                default:
 821                                        newfileset.logicalBlockNum++;
 822                                        brelse(bh);
 823                                        bh = NULL;
 824                                        break;
 825                                }
 826                        } while (newfileset.logicalBlockNum < lastblock &&
 827                                 fileset->logicalBlockNum == 0xFFFFFFFF &&
 828                                 fileset->partitionReferenceNum == 0xFFFF);
 829                }
 830        }
 831
 832        if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
 833             fileset->partitionReferenceNum != 0xFFFF) && bh) {
 834                udf_debug("Fileset at block=%d, partition=%d\n",
 835                          fileset->logicalBlockNum,
 836                          fileset->partitionReferenceNum);
 837
 838                sbi->s_partition = fileset->partitionReferenceNum;
 839                udf_load_fileset(sb, bh, root);
 840                brelse(bh);
 841                return 0;
 842        }
 843        return 1;
 844}
 845
 846static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
 847{
 848        struct primaryVolDesc *pvoldesc;
 849        struct ustr *instr, *outstr;
 850        struct buffer_head *bh;
 851        uint16_t ident;
 852        int ret = 1;
 853
 854        instr = kmalloc(sizeof(struct ustr), GFP_NOFS);
 855        if (!instr)
 856                return 1;
 857
 858        outstr = kmalloc(sizeof(struct ustr), GFP_NOFS);
 859        if (!outstr)
 860                goto out1;
 861
 862        bh = udf_read_tagged(sb, block, block, &ident);
 863        if (!bh)
 864                goto out2;
 865
 866        BUG_ON(ident != TAG_IDENT_PVD);
 867
 868        pvoldesc = (struct primaryVolDesc *)bh->b_data;
 869
 870        if (udf_disk_stamp_to_time(&UDF_SB(sb)->s_record_time,
 871                              pvoldesc->recordingDateAndTime)) {
 872#ifdef UDFFS_DEBUG
 873                struct timestamp *ts = &pvoldesc->recordingDateAndTime;
 874                udf_debug("recording time %04u/%02u/%02u %02u:%02u (%x)\n",
 875                          le16_to_cpu(ts->year), ts->month, ts->day, ts->hour,
 876                          ts->minute, le16_to_cpu(ts->typeAndTimezone));
 877#endif
 878        }
 879
 880        if (!udf_build_ustr(instr, pvoldesc->volIdent, 32))
 881                if (udf_CS0toUTF8(outstr, instr)) {
 882                        strncpy(UDF_SB(sb)->s_volume_ident, outstr->u_name,
 883                                outstr->u_len > 31 ? 31 : outstr->u_len);
 884                        udf_debug("volIdent[] = '%s'\n",
 885                                  UDF_SB(sb)->s_volume_ident);
 886                }
 887
 888        if (!udf_build_ustr(instr, pvoldesc->volSetIdent, 128))
 889                if (udf_CS0toUTF8(outstr, instr))
 890                        udf_debug("volSetIdent[] = '%s'\n", outstr->u_name);
 891
 892        brelse(bh);
 893        ret = 0;
 894out2:
 895        kfree(outstr);
 896out1:
 897        kfree(instr);
 898        return ret;
 899}
 900
 901struct inode *udf_find_metadata_inode_efe(struct super_block *sb,
 902                                        u32 meta_file_loc, u32 partition_num)
 903{
 904        struct kernel_lb_addr addr;
 905        struct inode *metadata_fe;
 906
 907        addr.logicalBlockNum = meta_file_loc;
 908        addr.partitionReferenceNum = partition_num;
 909
 910        metadata_fe = udf_iget(sb, &addr);
 911
 912        if (metadata_fe == NULL)
 913                udf_warn(sb, "metadata inode efe not found\n");
 914        else if (UDF_I(metadata_fe)->i_alloc_type != ICBTAG_FLAG_AD_SHORT) {
 915                udf_warn(sb, "metadata inode efe does not have short allocation descriptors!\n");
 916                iput(metadata_fe);
 917                metadata_fe = NULL;
 918        }
 919
 920        return metadata_fe;
 921}
 922
 923static int udf_load_metadata_files(struct super_block *sb, int partition)
 924{
 925        struct udf_sb_info *sbi = UDF_SB(sb);
 926        struct udf_part_map *map;
 927        struct udf_meta_data *mdata;
 928        struct kernel_lb_addr addr;
 929
 930        map = &sbi->s_partmaps[partition];
 931        mdata = &map->s_type_specific.s_metadata;
 932
 933        /* metadata address */
 934        udf_debug("Metadata file location: block = %d part = %d\n",
 935                  mdata->s_meta_file_loc, map->s_partition_num);
 936
 937        mdata->s_metadata_fe = udf_find_metadata_inode_efe(sb,
 938                mdata->s_meta_file_loc, map->s_partition_num);
 939
 940        if (mdata->s_metadata_fe == NULL) {
 941                /* mirror file entry */
 942                udf_debug("Mirror metadata file location: block = %d part = %d\n",
 943                          mdata->s_mirror_file_loc, map->s_partition_num);
 944
 945                mdata->s_mirror_fe = udf_find_metadata_inode_efe(sb,
 946                        mdata->s_mirror_file_loc, map->s_partition_num);
 947
 948                if (mdata->s_mirror_fe == NULL) {
 949                        udf_err(sb, "Both metadata and mirror metadata inode efe can not found\n");
 950                        goto error_exit;
 951                }
 952        }
 953
 954        /*
 955         * bitmap file entry
 956         * Note:
 957         * Load only if bitmap file location differs from 0xFFFFFFFF (DCN-5102)
 958        */
 959        if (mdata->s_bitmap_file_loc != 0xFFFFFFFF) {
 960                addr.logicalBlockNum = mdata->s_bitmap_file_loc;
 961                addr.partitionReferenceNum = map->s_partition_num;
 962
 963                udf_debug("Bitmap file location: block = %d part = %d\n",
 964                          addr.logicalBlockNum, addr.partitionReferenceNum);
 965
 966                mdata->s_bitmap_fe = udf_iget(sb, &addr);
 967
 968                if (mdata->s_bitmap_fe == NULL) {
 969                        if (sb->s_flags & MS_RDONLY)
 970                                udf_warn(sb, "bitmap inode efe not found but it's ok since the disc is mounted read-only\n");
 971                        else {
 972                                udf_err(sb, "bitmap inode efe not found and attempted read-write mount\n");
 973                                goto error_exit;
 974                        }
 975                }
 976        }
 977
 978        udf_debug("udf_load_metadata_files Ok\n");
 979
 980        return 0;
 981
 982error_exit:
 983        return 1;
 984}
 985
 986static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
 987                             struct kernel_lb_addr *root)
 988{
 989        struct fileSetDesc *fset;
 990
 991        fset = (struct fileSetDesc *)bh->b_data;
 992
 993        *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
 994
 995        UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
 996
 997        udf_debug("Rootdir at block=%d, partition=%d\n",
 998                  root->logicalBlockNum, root->partitionReferenceNum);
 999}
1000
1001int udf_compute_nr_groups(struct super_block *sb, u32 partition)
1002{
1003        struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
1004        return DIV_ROUND_UP(map->s_partition_len +
1005                            (sizeof(struct spaceBitmapDesc) << 3),
1006                            sb->s_blocksize * 8);
1007}
1008
1009static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
1010{
1011        struct udf_bitmap *bitmap;
1012        int nr_groups;
1013        int size;
1014
1015        nr_groups = udf_compute_nr_groups(sb, index);
1016        size = sizeof(struct udf_bitmap) +
1017                (sizeof(struct buffer_head *) * nr_groups);
1018
1019        if (size <= PAGE_SIZE)
1020                bitmap = kzalloc(size, GFP_KERNEL);
1021        else
1022                bitmap = vzalloc(size); /* TODO: get rid of vzalloc */
1023
1024        if (bitmap == NULL)
1025                return NULL;
1026
1027        bitmap->s_nr_groups = nr_groups;
1028        return bitmap;
1029}
1030
1031static int udf_fill_partdesc_info(struct super_block *sb,
1032                struct partitionDesc *p, int p_index)
1033{
1034        struct udf_part_map *map;
1035        struct udf_sb_info *sbi = UDF_SB(sb);
1036        struct partitionHeaderDesc *phd;
1037
1038        map = &sbi->s_partmaps[p_index];
1039
1040        map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */
1041        map->s_partition_root = le32_to_cpu(p->partitionStartingLocation);
1042
1043        if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY))
1044                map->s_partition_flags |= UDF_PART_FLAG_READ_ONLY;
1045        if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE))
1046                map->s_partition_flags |= UDF_PART_FLAG_WRITE_ONCE;
1047        if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE))
1048                map->s_partition_flags |= UDF_PART_FLAG_REWRITABLE;
1049        if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
1050                map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE;
1051
1052        udf_debug("Partition (%d type %x) starts at physical %d, block length %d\n",
1053                  p_index, map->s_partition_type,
1054                  map->s_partition_root, map->s_partition_len);
1055
1056        if (strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) &&
1057            strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03))
1058                return 0;
1059
1060        phd = (struct partitionHeaderDesc *)p->partitionContentsUse;
1061        if (phd->unallocSpaceTable.extLength) {
1062                struct kernel_lb_addr loc = {
1063                        .logicalBlockNum = le32_to_cpu(
1064                                phd->unallocSpaceTable.extPosition),
1065                        .partitionReferenceNum = p_index,
1066                };
1067
1068                map->s_uspace.s_table = udf_iget(sb, &loc);
1069                if (!map->s_uspace.s_table) {
1070                        udf_debug("cannot load unallocSpaceTable (part %d)\n",
1071                                  p_index);
1072                        return 1;
1073                }
1074                map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
1075                udf_debug("unallocSpaceTable (part %d) @ %ld\n",
1076                          p_index, map->s_uspace.s_table->i_ino);
1077        }
1078
1079        if (phd->unallocSpaceBitmap.extLength) {
1080                struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
1081                if (!bitmap)
1082                        return 1;
1083                map->s_uspace.s_bitmap = bitmap;
1084                bitmap->s_extPosition = le32_to_cpu(
1085                                phd->unallocSpaceBitmap.extPosition);
1086                map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
1087                udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
1088                          p_index, bitmap->s_extPosition);
1089        }
1090
1091        if (phd->partitionIntegrityTable.extLength)
1092                udf_debug("partitionIntegrityTable (part %d)\n", p_index);
1093
1094        if (phd->freedSpaceTable.extLength) {
1095                struct kernel_lb_addr loc = {
1096                        .logicalBlockNum = le32_to_cpu(
1097                                phd->freedSpaceTable.extPosition),
1098                        .partitionReferenceNum = p_index,
1099                };
1100
1101                map->s_fspace.s_table = udf_iget(sb, &loc);
1102                if (!map->s_fspace.s_table) {
1103                        udf_debug("cannot load freedSpaceTable (part %d)\n",
1104                                  p_index);
1105                        return 1;
1106                }
1107
1108                map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
1109                udf_debug("freedSpaceTable (part %d) @ %ld\n",
1110                          p_index, map->s_fspace.s_table->i_ino);
1111        }
1112
1113        if (phd->freedSpaceBitmap.extLength) {
1114                struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
1115                if (!bitmap)
1116                        return 1;
1117                map->s_fspace.s_bitmap = bitmap;
1118                bitmap->s_extPosition = le32_to_cpu(
1119                                phd->freedSpaceBitmap.extPosition);
1120                map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
1121                udf_debug("freedSpaceBitmap (part %d) @ %d\n",
1122                          p_index, bitmap->s_extPosition);
1123        }
1124        return 0;
1125}
1126
1127static void udf_find_vat_block(struct super_block *sb, int p_index,
1128                               int type1_index, sector_t start_block)
1129{
1130        struct udf_sb_info *sbi = UDF_SB(sb);
1131        struct udf_part_map *map = &sbi->s_partmaps[p_index];
1132        sector_t vat_block;
1133        struct kernel_lb_addr ino;
1134
1135        /*
1136         * VAT file entry is in the last recorded block. Some broken disks have
1137         * it a few blocks before so try a bit harder...
1138         */
1139        ino.partitionReferenceNum = type1_index;
1140        for (vat_block = start_block;
1141             vat_block >= map->s_partition_root &&
1142             vat_block >= start_block - 3 &&
1143             !sbi->s_vat_inode; vat_block--) {
1144                ino.logicalBlockNum = vat_block - map->s_partition_root;
1145                sbi->s_vat_inode = udf_iget(sb, &ino);
1146        }
1147}
1148
1149static int udf_load_vat(struct super_block *sb, int p_index, int type1_index)
1150{
1151        struct udf_sb_info *sbi = UDF_SB(sb);
1152        struct udf_part_map *map = &sbi->s_partmaps[p_index];
1153        struct buffer_head *bh = NULL;
1154        struct udf_inode_info *vati;
1155        uint32_t pos;
1156        struct virtualAllocationTable20 *vat20;
1157        sector_t blocks = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
1158
1159        udf_find_vat_block(sb, p_index, type1_index, sbi->s_last_block);
1160        if (!sbi->s_vat_inode &&
1161            sbi->s_last_block != blocks - 1) {
1162                pr_notice("Failed to read VAT inode from the last recorded block (%lu), retrying with the last block of the device (%lu).\n",
1163                          (unsigned long)sbi->s_last_block,
1164                          (unsigned long)blocks - 1);
1165                udf_find_vat_block(sb, p_index, type1_index, blocks - 1);
1166        }
1167        if (!sbi->s_vat_inode)
1168                return 1;
1169
1170        if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
1171                map->s_type_specific.s_virtual.s_start_offset = 0;
1172                map->s_type_specific.s_virtual.s_num_entries =
1173                        (sbi->s_vat_inode->i_size - 36) >> 2;
1174        } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
1175                vati = UDF_I(sbi->s_vat_inode);
1176                if (vati->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
1177                        pos = udf_block_map(sbi->s_vat_inode, 0);
1178                        bh = sb_bread(sb, pos);
1179                        if (!bh)
1180                                return 1;
1181                        vat20 = (struct virtualAllocationTable20 *)bh->b_data;
1182                } else {
1183                        vat20 = (struct virtualAllocationTable20 *)
1184                                                        vati->i_ext.i_data;
1185                }
1186
1187                map->s_type_specific.s_virtual.s_start_offset =
1188                        le16_to_cpu(vat20->lengthHeader);
1189                map->s_type_specific.s_virtual.s_num_entries =
1190                        (sbi->s_vat_inode->i_size -
1191                                map->s_type_specific.s_virtual.
1192                                        s_start_offset) >> 2;
1193                brelse(bh);
1194        }
1195        return 0;
1196}
1197
1198static int udf_load_partdesc(struct super_block *sb, sector_t block)
1199{
1200        struct buffer_head *bh;
1201        struct partitionDesc *p;
1202        struct udf_part_map *map;
1203        struct udf_sb_info *sbi = UDF_SB(sb);
1204        int i, type1_idx;
1205        uint16_t partitionNumber;
1206        uint16_t ident;
1207        int ret = 0;
1208
1209        bh = udf_read_tagged(sb, block, block, &ident);
1210        if (!bh)
1211                return 1;
1212        if (ident != TAG_IDENT_PD)
1213                goto out_bh;
1214
1215        p = (struct partitionDesc *)bh->b_data;
1216        partitionNumber = le16_to_cpu(p->partitionNumber);
1217
1218        /* First scan for TYPE1, SPARABLE and METADATA partitions */
1219        for (i = 0; i < sbi->s_partitions; i++) {
1220                map = &sbi->s_partmaps[i];
1221                udf_debug("Searching map: (%d == %d)\n",
1222                          map->s_partition_num, partitionNumber);
1223                if (map->s_partition_num == partitionNumber &&
1224                    (map->s_partition_type == UDF_TYPE1_MAP15 ||
1225                     map->s_partition_type == UDF_SPARABLE_MAP15))
1226                        break;
1227        }
1228
1229        if (i >= sbi->s_partitions) {
1230                udf_debug("Partition (%d) not found in partition map\n",
1231                          partitionNumber);
1232                goto out_bh;
1233        }
1234
1235        ret = udf_fill_partdesc_info(sb, p, i);
1236
1237        /*
1238         * Now rescan for VIRTUAL or METADATA partitions when SPARABLE and
1239         * PHYSICAL partitions are already set up
1240         */
1241        type1_idx = i;
1242        for (i = 0; i < sbi->s_partitions; i++) {
1243                map = &sbi->s_partmaps[i];
1244
1245                if (map->s_partition_num == partitionNumber &&
1246                    (map->s_partition_type == UDF_VIRTUAL_MAP15 ||
1247                     map->s_partition_type == UDF_VIRTUAL_MAP20 ||
1248                     map->s_partition_type == UDF_METADATA_MAP25))
1249                        break;
1250        }
1251
1252        if (i >= sbi->s_partitions)
1253                goto out_bh;
1254
1255        ret = udf_fill_partdesc_info(sb, p, i);
1256        if (ret)
1257                goto out_bh;
1258
1259        if (map->s_partition_type == UDF_METADATA_MAP25) {
1260                ret = udf_load_metadata_files(sb, i);
1261                if (ret) {
1262                        udf_err(sb, "error loading MetaData partition map %d\n",
1263                                i);
1264                        goto out_bh;
1265                }
1266        } else {
1267                ret = udf_load_vat(sb, i, type1_idx);
1268                if (ret)
1269                        goto out_bh;
1270                /*
1271                 * Mark filesystem read-only if we have a partition with
1272                 * virtual map since we don't handle writing to it (we
1273                 * overwrite blocks instead of relocating them).
1274                 */
1275                sb->s_flags |= MS_RDONLY;
1276                pr_notice("Filesystem marked read-only because writing to pseudooverwrite partition is not implemented\n");
1277        }
1278out_bh:
1279        /* In case loading failed, we handle cleanup in udf_fill_super */
1280        brelse(bh);
1281        return ret;
1282}
1283
1284static int udf_load_sparable_map(struct super_block *sb,
1285                                 struct udf_part_map *map,
1286                                 struct sparablePartitionMap *spm)
1287{
1288        uint32_t loc;
1289        uint16_t ident;
1290        struct sparingTable *st;
1291        struct udf_sparing_data *sdata = &map->s_type_specific.s_sparing;
1292        int i;
1293        struct buffer_head *bh;
1294
1295        map->s_partition_type = UDF_SPARABLE_MAP15;
1296        sdata->s_packet_len = le16_to_cpu(spm->packetLength);
1297        if (!is_power_of_2(sdata->s_packet_len)) {
1298                udf_err(sb, "error loading logical volume descriptor: "
1299                        "Invalid packet length %u\n",
1300                        (unsigned)sdata->s_packet_len);
1301                return -EIO;
1302        }
1303        if (spm->numSparingTables > 4) {
1304                udf_err(sb, "error loading logical volume descriptor: "
1305                        "Too many sparing tables (%d)\n",
1306                        (int)spm->numSparingTables);
1307                return -EIO;
1308        }
1309
1310        for (i = 0; i < spm->numSparingTables; i++) {
1311                loc = le32_to_cpu(spm->locSparingTable[i]);
1312                bh = udf_read_tagged(sb, loc, loc, &ident);
1313                if (!bh)
1314                        continue;
1315
1316                st = (struct sparingTable *)bh->b_data;
1317                if (ident != 0 ||
1318                    strncmp(st->sparingIdent.ident, UDF_ID_SPARING,
1319                            strlen(UDF_ID_SPARING)) ||
1320                    sizeof(*st) + le16_to_cpu(st->reallocationTableLen) >
1321                                                        sb->s_blocksize) {
1322                        brelse(bh);
1323                        continue;
1324                }
1325
1326                sdata->s_spar_map[i] = bh;
1327        }
1328        map->s_partition_func = udf_get_pblock_spar15;
1329        return 0;
1330}
1331
1332static int udf_load_logicalvol(struct super_block *sb, sector_t block,
1333                               struct kernel_lb_addr *fileset)
1334{
1335        struct logicalVolDesc *lvd;
1336        int i, offset;
1337        uint8_t type;
1338        struct udf_sb_info *sbi = UDF_SB(sb);
1339        struct genericPartitionMap *gpm;
1340        uint16_t ident;
1341        struct buffer_head *bh;
1342        unsigned int table_len;
1343        int ret = 0;
1344
1345        bh = udf_read_tagged(sb, block, block, &ident);
1346        if (!bh)
1347                return 1;
1348        BUG_ON(ident != TAG_IDENT_LVD);
1349        lvd = (struct logicalVolDesc *)bh->b_data;
1350        table_len = le32_to_cpu(lvd->mapTableLength);
1351        if (table_len > sb->s_blocksize - sizeof(*lvd)) {
1352                udf_err(sb, "error loading logical volume descriptor: "
1353                        "Partition table too long (%u > %lu)\n", table_len,
1354                        sb->s_blocksize - sizeof(*lvd));
1355                ret = 1;
1356                goto out_bh;
1357        }
1358
1359        ret = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
1360        if (ret)
1361                goto out_bh;
1362
1363        for (i = 0, offset = 0;
1364             i < sbi->s_partitions && offset < table_len;
1365             i++, offset += gpm->partitionMapLength) {
1366                struct udf_part_map *map = &sbi->s_partmaps[i];
1367                gpm = (struct genericPartitionMap *)
1368                                &(lvd->partitionMaps[offset]);
1369                type = gpm->partitionMapType;
1370                if (type == 1) {
1371                        struct genericPartitionMap1 *gpm1 =
1372                                (struct genericPartitionMap1 *)gpm;
1373                        map->s_partition_type = UDF_TYPE1_MAP15;
1374                        map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum);
1375                        map->s_partition_num = le16_to_cpu(gpm1->partitionNum);
1376                        map->s_partition_func = NULL;
1377                } else if (type == 2) {
1378                        struct udfPartitionMap2 *upm2 =
1379                                                (struct udfPartitionMap2 *)gpm;
1380                        if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL,
1381                                                strlen(UDF_ID_VIRTUAL))) {
1382                                u16 suf =
1383                                        le16_to_cpu(((__le16 *)upm2->partIdent.
1384                                                        identSuffix)[0]);
1385                                if (suf < 0x0200) {
1386                                        map->s_partition_type =
1387                                                        UDF_VIRTUAL_MAP15;
1388                                        map->s_partition_func =
1389                                                        udf_get_pblock_virt15;
1390                                } else {
1391                                        map->s_partition_type =
1392                                                        UDF_VIRTUAL_MAP20;
1393                                        map->s_partition_func =
1394                                                        udf_get_pblock_virt20;
1395                                }
1396                        } else if (!strncmp(upm2->partIdent.ident,
1397                                                UDF_ID_SPARABLE,
1398                                                strlen(UDF_ID_SPARABLE))) {
1399                                if (udf_load_sparable_map(sb, map,
1400                                    (struct sparablePartitionMap *)gpm) < 0) {
1401                                        ret = 1;
1402                                        goto out_bh;
1403                                }
1404                        } else if (!strncmp(upm2->partIdent.ident,
1405                                                UDF_ID_METADATA,
1406                                                strlen(UDF_ID_METADATA))) {
1407                                struct udf_meta_data *mdata =
1408                                        &map->s_type_specific.s_metadata;
1409                                struct metadataPartitionMap *mdm =
1410                                                (struct metadataPartitionMap *)
1411                                                &(lvd->partitionMaps[offset]);
1412                                udf_debug("Parsing Logical vol part %d type %d  id=%s\n",
1413                                          i, type, UDF_ID_METADATA);
1414
1415                                map->s_partition_type = UDF_METADATA_MAP25;
1416                                map->s_partition_func = udf_get_pblock_meta25;
1417
1418                                mdata->s_meta_file_loc   =
1419                                        le32_to_cpu(mdm->metadataFileLoc);
1420                                mdata->s_mirror_file_loc =
1421                                        le32_to_cpu(mdm->metadataMirrorFileLoc);
1422                                mdata->s_bitmap_file_loc =
1423                                        le32_to_cpu(mdm->metadataBitmapFileLoc);
1424                                mdata->s_alloc_unit_size =
1425                                        le32_to_cpu(mdm->allocUnitSize);
1426                                mdata->s_align_unit_size =
1427                                        le16_to_cpu(mdm->alignUnitSize);
1428                                if (mdm->flags & 0x01)
1429                                        mdata->s_flags |= MF_DUPLICATE_MD;
1430
1431                                udf_debug("Metadata Ident suffix=0x%x\n",
1432                                          le16_to_cpu(*(__le16 *)
1433                                                      mdm->partIdent.identSuffix));
1434                                udf_debug("Metadata part num=%d\n",
1435                                          le16_to_cpu(mdm->partitionNum));
1436                                udf_debug("Metadata part alloc unit size=%d\n",
1437                                          le32_to_cpu(mdm->allocUnitSize));
1438                                udf_debug("Metadata file loc=%d\n",
1439                                          le32_to_cpu(mdm->metadataFileLoc));
1440                                udf_debug("Mirror file loc=%d\n",
1441                                          le32_to_cpu(mdm->metadataMirrorFileLoc));
1442                                udf_debug("Bitmap file loc=%d\n",
1443                                          le32_to_cpu(mdm->metadataBitmapFileLoc));
1444                                udf_debug("Flags: %d %d\n",
1445                                          mdata->s_flags, mdm->flags);
1446                        } else {
1447                                udf_debug("Unknown ident: %s\n",
1448                                          upm2->partIdent.ident);
1449                                continue;
1450                        }
1451                        map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
1452                        map->s_partition_num = le16_to_cpu(upm2->partitionNum);
1453                }
1454                udf_debug("Partition (%d:%d) type %d on volume %d\n",
1455                          i, map->s_partition_num, type, map->s_volumeseqnum);
1456        }
1457
1458        if (fileset) {
1459                struct long_ad *la = (struct long_ad *)&(lvd->logicalVolContentsUse[0]);
1460
1461                *fileset = lelb_to_cpu(la->extLocation);
1462                udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
1463                          fileset->logicalBlockNum,
1464                          fileset->partitionReferenceNum);
1465        }
1466        if (lvd->integritySeqExt.extLength)
1467                udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
1468
1469out_bh:
1470        brelse(bh);
1471        return ret;
1472}
1473
1474/*
1475 * udf_load_logicalvolint
1476 *
1477 */
1478static void udf_load_logicalvolint(struct super_block *sb, struct kernel_extent_ad loc)
1479{
1480        struct buffer_head *bh = NULL;
1481        uint16_t ident;
1482        struct udf_sb_info *sbi = UDF_SB(sb);
1483        struct logicalVolIntegrityDesc *lvid;
1484
1485        while (loc.extLength > 0 &&
1486               (bh = udf_read_tagged(sb, loc.extLocation,
1487                                     loc.extLocation, &ident)) &&
1488               ident == TAG_IDENT_LVID) {
1489                sbi->s_lvid_bh = bh;
1490                lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
1491
1492                if (lvid->nextIntegrityExt.extLength)
1493                        udf_load_logicalvolint(sb,
1494                                leea_to_cpu(lvid->nextIntegrityExt));
1495
1496                if (sbi->s_lvid_bh != bh)
1497                        brelse(bh);
1498                loc.extLength -= sb->s_blocksize;
1499                loc.extLocation++;
1500        }
1501        if (sbi->s_lvid_bh != bh)
1502                brelse(bh);
1503}
1504
1505/*
1506 * udf_process_sequence
1507 *
1508 * PURPOSE
1509 *      Process a main/reserve volume descriptor sequence.
1510 *
1511 * PRE-CONDITIONS
1512 *      sb                      Pointer to _locked_ superblock.
1513 *      block                   First block of first extent of the sequence.
1514 *      lastblock               Lastblock of first extent of the sequence.
1515 *
1516 * HISTORY
1517 *      July 1, 1997 - Andrew E. Mileski
1518 *      Written, tested, and released.
1519 */
1520static noinline int udf_process_sequence(struct super_block *sb, long block,
1521                                long lastblock, struct kernel_lb_addr *fileset)
1522{
1523        struct buffer_head *bh = NULL;
1524        struct udf_vds_record vds[VDS_POS_LENGTH];
1525        struct udf_vds_record *curr;
1526        struct generic_desc *gd;
1527        struct volDescPtr *vdp;
1528        int done = 0;
1529        uint32_t vdsn;
1530        uint16_t ident;
1531        long next_s = 0, next_e = 0;
1532
1533        memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);
1534
1535        /*
1536         * Read the main descriptor sequence and find which descriptors
1537         * are in it.
1538         */
1539        for (; (!done && block <= lastblock); block++) {
1540
1541                bh = udf_read_tagged(sb, block, block, &ident);
1542                if (!bh) {
1543                        udf_err(sb,
1544                                "Block %llu of volume descriptor sequence is corrupted or we could not read it\n",
1545                                (unsigned long long)block);
1546                        return 1;
1547                }
1548
1549                /* Process each descriptor (ISO 13346 3/8.3-8.4) */
1550                gd = (struct generic_desc *)bh->b_data;
1551                vdsn = le32_to_cpu(gd->volDescSeqNum);
1552                switch (ident) {
1553                case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
1554                        curr = &vds[VDS_POS_PRIMARY_VOL_DESC];
1555                        if (vdsn >= curr->volDescSeqNum) {
1556                                curr->volDescSeqNum = vdsn;
1557                                curr->block = block;
1558                        }
1559                        break;
1560                case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
1561                        curr = &vds[VDS_POS_VOL_DESC_PTR];
1562                        if (vdsn >= curr->volDescSeqNum) {
1563                                curr->volDescSeqNum = vdsn;
1564                                curr->block = block;
1565
1566                                vdp = (struct volDescPtr *)bh->b_data;
1567                                next_s = le32_to_cpu(
1568                                        vdp->nextVolDescSeqExt.extLocation);
1569                                next_e = le32_to_cpu(
1570                                        vdp->nextVolDescSeqExt.extLength);
1571                                next_e = next_e >> sb->s_blocksize_bits;
1572                                next_e += next_s;
1573                        }
1574                        break;
1575                case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
1576                        curr = &vds[VDS_POS_IMP_USE_VOL_DESC];
1577                        if (vdsn >= curr->volDescSeqNum) {
1578                                curr->volDescSeqNum = vdsn;
1579                                curr->block = block;
1580                        }
1581                        break;
1582                case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
1583                        curr = &vds[VDS_POS_PARTITION_DESC];
1584                        if (!curr->block)
1585                                curr->block = block;
1586                        break;
1587                case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
1588                        curr = &vds[VDS_POS_LOGICAL_VOL_DESC];
1589                        if (vdsn >= curr->volDescSeqNum) {
1590                                curr->volDescSeqNum = vdsn;
1591                                curr->block = block;
1592                        }
1593                        break;
1594                case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
1595                        curr = &vds[VDS_POS_UNALLOC_SPACE_DESC];
1596                        if (vdsn >= curr->volDescSeqNum) {
1597                                curr->volDescSeqNum = vdsn;
1598                                curr->block = block;
1599                        }
1600                        break;
1601                case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
1602                        vds[VDS_POS_TERMINATING_DESC].block = block;
1603                        if (next_e) {
1604                                block = next_s;
1605                                lastblock = next_e;
1606                                next_s = next_e = 0;
1607                        } else
1608                                done = 1;
1609                        break;
1610                }
1611                brelse(bh);
1612        }
1613        /*
1614         * Now read interesting descriptors again and process them
1615         * in a suitable order
1616         */
1617        if (!vds[VDS_POS_PRIMARY_VOL_DESC].block) {
1618                udf_err(sb, "Primary Volume Descriptor not found!\n");
1619                return 1;
1620        }
1621        if (udf_load_pvoldesc(sb, vds[VDS_POS_PRIMARY_VOL_DESC].block))
1622                return 1;
1623
1624        if (vds[VDS_POS_LOGICAL_VOL_DESC].block && udf_load_logicalvol(sb,
1625            vds[VDS_POS_LOGICAL_VOL_DESC].block, fileset))
1626                return 1;
1627
1628        if (vds[VDS_POS_PARTITION_DESC].block) {
1629                /*
1630                 * We rescan the whole descriptor sequence to find
1631                 * partition descriptor blocks and process them.
1632                 */
1633                for (block = vds[VDS_POS_PARTITION_DESC].block;
1634                     block < vds[VDS_POS_TERMINATING_DESC].block;
1635                     block++)
1636                        if (udf_load_partdesc(sb, block))
1637                                return 1;
1638        }
1639
1640        return 0;
1641}
1642
1643static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
1644                             struct kernel_lb_addr *fileset)
1645{
1646        struct anchorVolDescPtr *anchor;
1647        long main_s, main_e, reserve_s, reserve_e;
1648
1649        anchor = (struct anchorVolDescPtr *)bh->b_data;
1650
1651        /* Locate the main sequence */
1652        main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
1653        main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
1654        main_e = main_e >> sb->s_blocksize_bits;
1655        main_e += main_s;
1656
1657        /* Locate the reserve sequence */
1658        reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
1659        reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
1660        reserve_e = reserve_e >> sb->s_blocksize_bits;
1661        reserve_e += reserve_s;
1662
1663        /* Process the main & reserve sequences */
1664        /* responsible for finding the PartitionDesc(s) */
1665        if (!udf_process_sequence(sb, main_s, main_e, fileset))
1666                return 1;
1667        udf_sb_free_partitions(sb);
1668        if (!udf_process_sequence(sb, reserve_s, reserve_e, fileset))
1669                return 1;
1670        udf_sb_free_partitions(sb);
1671        return 0;
1672}
1673
1674/*
1675 * Check whether there is an anchor block in the given block and
1676 * load Volume Descriptor Sequence if so.
1677 */
1678static int udf_check_anchor_block(struct super_block *sb, sector_t block,
1679                                  struct kernel_lb_addr *fileset)
1680{
1681        struct buffer_head *bh;
1682        uint16_t ident;
1683        int ret;
1684
1685        if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV) &&
1686            udf_fixed_to_variable(block) >=
1687            sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits)
1688                return 0;
1689
1690        bh = udf_read_tagged(sb, block, block, &ident);
1691        if (!bh)
1692                return 0;
1693        if (ident != TAG_IDENT_AVDP) {
1694                brelse(bh);
1695                return 0;
1696        }
1697        ret = udf_load_sequence(sb, bh, fileset);
1698        brelse(bh);
1699        return ret;
1700}
1701
1702/* Search for an anchor volume descriptor pointer */
1703static sector_t udf_scan_anchors(struct super_block *sb, sector_t lastblock,
1704                                 struct kernel_lb_addr *fileset)
1705{
1706        sector_t last[6];
1707        int i;
1708        struct udf_sb_info *sbi = UDF_SB(sb);
1709        int last_count = 0;
1710
1711        /* First try user provided anchor */
1712        if (sbi->s_anchor) {
1713                if (udf_check_anchor_block(sb, sbi->s_anchor, fileset))
1714                        return lastblock;
1715        }
1716        /*
1717         * according to spec, anchor is in either:
1718         *     block 256
1719         *     lastblock-256
1720         *     lastblock
1721         *  however, if the disc isn't closed, it could be 512.
1722         */
1723        if (udf_check_anchor_block(sb, sbi->s_session + 256, fileset))
1724                return lastblock;
1725        /*
1726         * The trouble is which block is the last one. Drives often misreport
1727         * this so we try various possibilities.
1728         */
1729        last[last_count++] = lastblock;
1730        if (lastblock >= 1)
1731                last[last_count++] = lastblock - 1;
1732        last[last_count++] = lastblock + 1;
1733        if (lastblock >= 2)
1734                last[last_count++] = lastblock - 2;
1735        if (lastblock >= 150)
1736                last[last_count++] = lastblock - 150;
1737        if (lastblock >= 152)
1738                last[last_count++] = lastblock - 152;
1739
1740        for (i = 0; i < last_count; i++) {
1741                if (last[i] >= sb->s_bdev->bd_inode->i_size >>
1742                                sb->s_blocksize_bits)
1743                        continue;
1744                if (udf_check_anchor_block(sb, last[i], fileset))
1745                        return last[i];
1746                if (last[i] < 256)
1747                        continue;
1748                if (udf_check_anchor_block(sb, last[i] - 256, fileset))
1749                        return last[i];
1750        }
1751
1752        /* Finally try block 512 in case media is open */
1753        if (udf_check_anchor_block(sb, sbi->s_session + 512, fileset))
1754                return last[0];
1755        return 0;
1756}
1757
1758/*
1759 * Find an anchor volume descriptor and load Volume Descriptor Sequence from
1760 * area specified by it. The function expects sbi->s_lastblock to be the last
1761 * block on the media.
1762 *
1763 * Return 1 if ok, 0 if not found.
1764 *
1765 */
1766static int udf_find_anchor(struct super_block *sb,
1767                           struct kernel_lb_addr *fileset)
1768{
1769        sector_t lastblock;
1770        struct udf_sb_info *sbi = UDF_SB(sb);
1771
1772        lastblock = udf_scan_anchors(sb, sbi->s_last_block, fileset);
1773        if (lastblock)
1774                goto out;
1775
1776        /* No anchor found? Try VARCONV conversion of block numbers */
1777        UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
1778        /* Firstly, we try to not convert number of the last block */
1779        lastblock = udf_scan_anchors(sb,
1780                                udf_variable_to_fixed(sbi->s_last_block),
1781                                fileset);
1782        if (lastblock)
1783                goto out;
1784
1785        /* Secondly, we try with converted number of the last block */
1786        lastblock = udf_scan_anchors(sb, sbi->s_last_block, fileset);
1787        if (!lastblock) {
1788                /* VARCONV didn't help. Clear it. */
1789                UDF_CLEAR_FLAG(sb, UDF_FLAG_VARCONV);
1790                return 0;
1791        }
1792out:
1793        sbi->s_last_block = lastblock;
1794        return 1;
1795}
1796
1797/*
1798 * Check Volume Structure Descriptor, find Anchor block and load Volume
1799 * Descriptor Sequence
1800 */
1801static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
1802                        int silent, struct kernel_lb_addr *fileset)
1803{
1804        struct udf_sb_info *sbi = UDF_SB(sb);
1805        loff_t nsr_off;
1806
1807        if (!sb_set_blocksize(sb, uopt->blocksize)) {
1808                if (!silent)
1809                        udf_warn(sb, "Bad block size\n");
1810                return 0;
1811        }
1812        sbi->s_last_block = uopt->lastblock;
1813        if (!uopt->novrs) {
1814                /* Check that it is NSR02 compliant */
1815                nsr_off = udf_check_vsd(sb);
1816                if (!nsr_off) {
1817                        if (!silent)
1818                                udf_warn(sb, "No VRS found\n");
1819                        return 0;
1820                }
1821                if (nsr_off == -1)
1822                        udf_debug("Failed to read byte 32768. Assuming open disc. Skipping validity check\n");
1823                if (!sbi->s_last_block)
1824                        sbi->s_last_block = udf_get_last_block(sb);
1825        } else {
1826                udf_debug("Validity check skipped because of novrs option\n");
1827        }
1828
1829        /* Look for anchor block and load Volume Descriptor Sequence */
1830        sbi->s_anchor = uopt->anchor;
1831        if (!udf_find_anchor(sb, fileset)) {
1832                if (!silent)
1833                        udf_warn(sb, "No anchor found\n");
1834                return 0;
1835        }
1836        return 1;
1837}
1838
1839static void udf_open_lvid(struct super_block *sb)
1840{
1841        struct udf_sb_info *sbi = UDF_SB(sb);
1842        struct buffer_head *bh = sbi->s_lvid_bh;
1843        struct logicalVolIntegrityDesc *lvid;
1844        struct logicalVolIntegrityDescImpUse *lvidiu;
1845
1846        if (!bh)
1847                return;
1848
1849        mutex_lock(&sbi->s_alloc_mutex);
1850        lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
1851        lvidiu = udf_sb_lvidiu(sbi);
1852
1853        lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1854        lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1855        udf_time_to_disk_stamp(&lvid->recordingDateAndTime,
1856                                CURRENT_TIME);
1857        lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_OPEN);
1858
1859        lvid->descTag.descCRC = cpu_to_le16(
1860                crc_itu_t(0, (char *)lvid + sizeof(struct tag),
1861                        le16_to_cpu(lvid->descTag.descCRCLength)));
1862
1863        lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
1864        mark_buffer_dirty(bh);
1865        sbi->s_lvid_dirty = 0;
1866        mutex_unlock(&sbi->s_alloc_mutex);
1867        /* Make opening of filesystem visible on the media immediately */
1868        sync_dirty_buffer(bh);
1869}
1870
1871static void udf_close_lvid(struct super_block *sb)
1872{
1873        struct udf_sb_info *sbi = UDF_SB(sb);
1874        struct buffer_head *bh = sbi->s_lvid_bh;
1875        struct logicalVolIntegrityDesc *lvid;
1876        struct logicalVolIntegrityDescImpUse *lvidiu;
1877
1878        if (!bh)
1879                return;
1880
1881        mutex_lock(&sbi->s_alloc_mutex);
1882        lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
1883        lvidiu = udf_sb_lvidiu(sbi);
1884        lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1885        lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1886        udf_time_to_disk_stamp(&lvid->recordingDateAndTime, CURRENT_TIME);
1887        if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))
1888                lvidiu->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
1889        if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev))
1890                lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev);
1891        if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev))
1892                lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev);
1893        lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
1894
1895        lvid->descTag.descCRC = cpu_to_le16(
1896                        crc_itu_t(0, (char *)lvid + sizeof(struct tag),
1897                                le16_to_cpu(lvid->descTag.descCRCLength)));
1898
1899        lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
1900        /*
1901         * We set buffer uptodate unconditionally here to avoid spurious
1902         * warnings from mark_buffer_dirty() when previous EIO has marked
1903         * the buffer as !uptodate
1904         */
1905        set_buffer_uptodate(bh);
1906        mark_buffer_dirty(bh);
1907        sbi->s_lvid_dirty = 0;
1908        mutex_unlock(&sbi->s_alloc_mutex);
1909        /* Make closing of filesystem visible on the media immediately */
1910        sync_dirty_buffer(bh);
1911}
1912
1913u64 lvid_get_unique_id(struct super_block *sb)
1914{
1915        struct buffer_head *bh;
1916        struct udf_sb_info *sbi = UDF_SB(sb);
1917        struct logicalVolIntegrityDesc *lvid;
1918        struct logicalVolHeaderDesc *lvhd;
1919        u64 uniqueID;
1920        u64 ret;
1921
1922        bh = sbi->s_lvid_bh;
1923        if (!bh)
1924                return 0;
1925
1926        lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
1927        lvhd = (struct logicalVolHeaderDesc *)lvid->logicalVolContentsUse;
1928
1929        mutex_lock(&sbi->s_alloc_mutex);
1930        ret = uniqueID = le64_to_cpu(lvhd->uniqueID);
1931        if (!(++uniqueID & 0xFFFFFFFF))
1932                uniqueID += 16;
1933        lvhd->uniqueID = cpu_to_le64(uniqueID);
1934        mutex_unlock(&sbi->s_alloc_mutex);
1935        mark_buffer_dirty(bh);
1936
1937        return ret;
1938}
1939
1940static int udf_fill_super(struct super_block *sb, void *options, int silent)
1941{
1942        int ret;
1943        struct inode *inode = NULL;
1944        struct udf_options uopt;
1945        struct kernel_lb_addr rootdir, fileset;
1946        struct udf_sb_info *sbi;
1947
1948        uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
1949        uopt.uid = INVALID_UID;
1950        uopt.gid = INVALID_GID;
1951        uopt.umask = 0;
1952        uopt.fmode = UDF_INVALID_MODE;
1953        uopt.dmode = UDF_INVALID_MODE;
1954
1955        sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
1956        if (!sbi)
1957                return -ENOMEM;
1958
1959        sb->s_fs_info = sbi;
1960
1961        mutex_init(&sbi->s_alloc_mutex);
1962
1963        if (!udf_parse_options((char *)options, &uopt, false))
1964                goto error_out;
1965
1966        if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
1967            uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
1968                udf_err(sb, "utf8 cannot be combined with iocharset\n");
1969                goto error_out;
1970        }
1971#ifdef CONFIG_UDF_NLS
1972        if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) {
1973                uopt.nls_map = load_nls_default();
1974                if (!uopt.nls_map)
1975                        uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP);
1976                else
1977                        udf_debug("Using default NLS map\n");
1978        }
1979#endif
1980        if (!(uopt.flags & (1 << UDF_FLAG_NLS_MAP)))
1981                uopt.flags |= (1 << UDF_FLAG_UTF8);
1982
1983        fileset.logicalBlockNum = 0xFFFFFFFF;
1984        fileset.partitionReferenceNum = 0xFFFF;
1985
1986        sbi->s_flags = uopt.flags;
1987        sbi->s_uid = uopt.uid;
1988        sbi->s_gid = uopt.gid;
1989        sbi->s_umask = uopt.umask;
1990        sbi->s_fmode = uopt.fmode;
1991        sbi->s_dmode = uopt.dmode;
1992        sbi->s_nls_map = uopt.nls_map;
1993        rwlock_init(&sbi->s_cred_lock);
1994
1995        if (uopt.session == 0xFFFFFFFF)
1996                sbi->s_session = udf_get_last_session(sb);
1997        else
1998                sbi->s_session = uopt.session;
1999
2000        udf_debug("Multi-session=%d\n", sbi->s_session);
2001
2002        /* Fill in the rest of the superblock */
2003        sb->s_op = &udf_sb_ops;
2004        sb->s_export_op = &udf_export_ops;
2005
2006        sb->s_magic = UDF_SUPER_MAGIC;
2007        sb->s_time_gran = 1000;
2008
2009        if (uopt.flags & (1 << UDF_FLAG_BLOCKSIZE_SET)) {
2010                ret = udf_load_vrs(sb, &uopt, silent, &fileset);
2011        } else {
2012                uopt.blocksize = bdev_logical_block_size(sb->s_bdev);
2013                ret = udf_load_vrs(sb, &uopt, silent, &fileset);
2014                if (!ret && uopt.blocksize != UDF_DEFAULT_BLOCKSIZE) {
2015                        if (!silent)
2016                                pr_notice("Rescanning with blocksize %d\n",
2017                                          UDF_DEFAULT_BLOCKSIZE);
2018                        brelse(sbi->s_lvid_bh);
2019                        sbi->s_lvid_bh = NULL;
2020                        uopt.blocksize = UDF_DEFAULT_BLOCKSIZE;
2021                        ret = udf_load_vrs(sb, &uopt, silent, &fileset);
2022                }
2023        }
2024        if (!ret) {
2025                udf_warn(sb, "No partition found (1)\n");
2026                goto error_out;
2027        }
2028
2029        udf_debug("Lastblock=%d\n", sbi->s_last_block);
2030
2031        if (sbi->s_lvid_bh) {
2032                struct logicalVolIntegrityDescImpUse *lvidiu =
2033                                                        udf_sb_lvidiu(sbi);
2034                uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
2035                uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
2036                /* uint16_t maxUDFWriteRev =
2037                                le16_to_cpu(lvidiu->maxUDFWriteRev); */
2038
2039                if (minUDFReadRev > UDF_MAX_READ_VERSION) {
2040                        udf_err(sb, "minUDFReadRev=%x (max is %x)\n",
2041                                le16_to_cpu(lvidiu->minUDFReadRev),
2042                                UDF_MAX_READ_VERSION);
2043                        goto error_out;
2044                } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
2045                        sb->s_flags |= MS_RDONLY;
2046
2047                sbi->s_udfrev = minUDFWriteRev;
2048
2049                if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
2050                        UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
2051                if (minUDFReadRev >= UDF_VERS_USE_STREAMS)
2052                        UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
2053        }
2054
2055        if (!sbi->s_partitions) {
2056                udf_warn(sb, "No partition found (2)\n");
2057                goto error_out;
2058        }
2059
2060        if (sbi->s_partmaps[sbi->s_partition].s_partition_flags &
2061                        UDF_PART_FLAG_READ_ONLY) {
2062                pr_notice("Partition marked readonly; forcing readonly mount\n");
2063                sb->s_flags |= MS_RDONLY;
2064        }
2065
2066        if (udf_find_fileset(sb, &fileset, &rootdir)) {
2067                udf_warn(sb, "No fileset found\n");
2068                goto error_out;
2069        }
2070
2071        if (!silent) {
2072                struct timestamp ts;
2073                udf_time_to_disk_stamp(&ts, sbi->s_record_time);
2074                udf_info("Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
2075                         sbi->s_volume_ident,
2076                         le16_to_cpu(ts.year), ts.month, ts.day,
2077                         ts.hour, ts.minute, le16_to_cpu(ts.typeAndTimezone));
2078        }
2079        if (!(sb->s_flags & MS_RDONLY))
2080                udf_open_lvid(sb);
2081
2082        /* Assign the root inode */
2083        /* assign inodes by physical block number */
2084        /* perhaps it's not extensible enough, but for now ... */
2085        inode = udf_iget(sb, &rootdir);
2086        if (!inode) {
2087                udf_err(sb, "Error in udf_iget, block=%d, partition=%d\n",
2088                       rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
2089                goto error_out;
2090        }
2091
2092        /* Allocate a dentry for the root inode */
2093        sb->s_root = d_make_root(inode);
2094        if (!sb->s_root) {
2095                udf_err(sb, "Couldn't allocate root dentry\n");
2096                goto error_out;
2097        }
2098        sb->s_maxbytes = MAX_LFS_FILESIZE;
2099        sb->s_max_links = UDF_MAX_LINKS;
2100        return 0;
2101
2102error_out:
2103        if (sbi->s_vat_inode)
2104                iput(sbi->s_vat_inode);
2105#ifdef CONFIG_UDF_NLS
2106        if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
2107                unload_nls(sbi->s_nls_map);
2108#endif
2109        if (!(sb->s_flags & MS_RDONLY))
2110                udf_close_lvid(sb);
2111        brelse(sbi->s_lvid_bh);
2112        udf_sb_free_partitions(sb);
2113        kfree(sbi);
2114        sb->s_fs_info = NULL;
2115
2116        return -EINVAL;
2117}
2118
2119void _udf_err(struct super_block *sb, const char *function,
2120              const char *fmt, ...)
2121{
2122        struct va_format vaf;
2123        va_list args;
2124
2125        va_start(args, fmt);
2126
2127        vaf.fmt = fmt;
2128        vaf.va = &args;
2129
2130        pr_err("error (device %s): %s: %pV", sb->s_id, function, &vaf);
2131
2132        va_end(args);
2133}
2134
2135void _udf_warn(struct super_block *sb, const char *function,
2136               const char *fmt, ...)
2137{
2138        struct va_format vaf;
2139        va_list args;
2140
2141        va_start(args, fmt);
2142
2143        vaf.fmt = fmt;
2144        vaf.va = &args;
2145
2146        pr_warn("warning (device %s): %s: %pV", sb->s_id, function, &vaf);
2147
2148        va_end(args);
2149}
2150
2151static void udf_put_super(struct super_block *sb)
2152{
2153        struct udf_sb_info *sbi;
2154
2155        sbi = UDF_SB(sb);
2156
2157        if (sbi->s_vat_inode)
2158                iput(sbi->s_vat_inode);
2159#ifdef CONFIG_UDF_NLS
2160        if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
2161                unload_nls(sbi->s_nls_map);
2162#endif
2163        if (!(sb->s_flags & MS_RDONLY))
2164                udf_close_lvid(sb);
2165        brelse(sbi->s_lvid_bh);
2166        udf_sb_free_partitions(sb);
2167        kfree(sb->s_fs_info);
2168        sb->s_fs_info = NULL;
2169}
2170
2171static int udf_sync_fs(struct super_block *sb, int wait)
2172{
2173        struct udf_sb_info *sbi = UDF_SB(sb);
2174
2175        mutex_lock(&sbi->s_alloc_mutex);
2176        if (sbi->s_lvid_dirty) {
2177                /*
2178                 * Blockdevice will be synced later so we don't have to submit
2179                 * the buffer for IO
2180                 */
2181                mark_buffer_dirty(sbi->s_lvid_bh);
2182                sbi->s_lvid_dirty = 0;
2183        }
2184        mutex_unlock(&sbi->s_alloc_mutex);
2185
2186        return 0;
2187}
2188
2189static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
2190{
2191        struct super_block *sb = dentry->d_sb;
2192        struct udf_sb_info *sbi = UDF_SB(sb);
2193        struct logicalVolIntegrityDescImpUse *lvidiu;
2194        u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
2195
2196        if (sbi->s_lvid_bh != NULL)
2197                lvidiu = udf_sb_lvidiu(sbi);
2198        else
2199                lvidiu = NULL;
2200
2201        buf->f_type = UDF_SUPER_MAGIC;
2202        buf->f_bsize = sb->s_blocksize;
2203        buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
2204        buf->f_bfree = udf_count_free(sb);
2205        buf->f_bavail = buf->f_bfree;
2206        buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
2207                                          le32_to_cpu(lvidiu->numDirs)) : 0)
2208                        + buf->f_bfree;
2209        buf->f_ffree = buf->f_bfree;
2210        buf->f_namelen = UDF_NAME_LEN - 2;
2211        buf->f_fsid.val[0] = (u32)id;
2212        buf->f_fsid.val[1] = (u32)(id >> 32);
2213
2214        return 0;
2215}
2216
2217static unsigned int udf_count_free_bitmap(struct super_block *sb,
2218                                          struct udf_bitmap *bitmap)
2219{
2220        struct buffer_head *bh = NULL;
2221        unsigned int accum = 0;
2222        int index;
2223        int block = 0, newblock;
2224        struct kernel_lb_addr loc;
2225        uint32_t bytes;
2226        uint8_t *ptr;
2227        uint16_t ident;
2228        struct spaceBitmapDesc *bm;
2229
2230        loc.logicalBlockNum = bitmap->s_extPosition;
2231        loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
2232        bh = udf_read_ptagged(sb, &loc, 0, &ident);
2233
2234        if (!bh) {
2235                udf_err(sb, "udf_count_free failed\n");
2236                goto out;
2237        } else if (ident != TAG_IDENT_SBD) {
2238                brelse(bh);
2239                udf_err(sb, "udf_count_free failed\n");
2240                goto out;
2241        }
2242
2243        bm = (struct spaceBitmapDesc *)bh->b_data;
2244        bytes = le32_to_cpu(bm->numOfBytes);
2245        index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
2246        ptr = (uint8_t *)bh->b_data;
2247
2248        while (bytes > 0) {
2249                u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index);
2250                accum += bitmap_weight((const unsigned long *)(ptr + index),
2251                                        cur_bytes * 8);
2252                bytes -= cur_bytes;
2253                if (bytes) {
2254                        brelse(bh);
2255                        newblock = udf_get_lb_pblock(sb, &loc, ++block);
2256                        bh = udf_tread(sb, newblock);
2257                        if (!bh) {
2258                                udf_debug("read failed\n");
2259                                goto out;
2260                        }
2261                        index = 0;
2262                        ptr = (uint8_t *)bh->b_data;
2263                }
2264        }
2265        brelse(bh);
2266out:
2267        return accum;
2268}
2269
2270static unsigned int udf_count_free_table(struct super_block *sb,
2271                                         struct inode *table)
2272{
2273        unsigned int accum = 0;
2274        uint32_t elen;
2275        struct kernel_lb_addr eloc;
2276        int8_t etype;
2277        struct extent_position epos;
2278
2279        mutex_lock(&UDF_SB(sb)->s_alloc_mutex);
2280        epos.block = UDF_I(table)->i_location;
2281        epos.offset = sizeof(struct unallocSpaceEntry);
2282        epos.bh = NULL;
2283
2284        while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
2285                accum += (elen >> table->i_sb->s_blocksize_bits);
2286
2287        brelse(epos.bh);
2288        mutex_unlock(&UDF_SB(sb)->s_alloc_mutex);
2289
2290        return accum;
2291}
2292
2293static unsigned int udf_count_free(struct super_block *sb)
2294{
2295        unsigned int accum = 0;
2296        struct udf_sb_info *sbi;
2297        struct udf_part_map *map;
2298
2299        sbi = UDF_SB(sb);
2300        if (sbi->s_lvid_bh) {
2301                struct logicalVolIntegrityDesc *lvid =
2302                        (struct logicalVolIntegrityDesc *)
2303                        sbi->s_lvid_bh->b_data;
2304                if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) {
2305                        accum = le32_to_cpu(
2306                                        lvid->freeSpaceTable[sbi->s_partition]);
2307                        if (accum == 0xFFFFFFFF)
2308                                accum = 0;
2309                }
2310        }
2311
2312        if (accum)
2313                return accum;
2314
2315        map = &sbi->s_partmaps[sbi->s_partition];
2316        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
2317                accum += udf_count_free_bitmap(sb,
2318                                               map->s_uspace.s_bitmap);
2319        }
2320        if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
2321                accum += udf_count_free_bitmap(sb,
2322                                               map->s_fspace.s_bitmap);
2323        }
2324        if (accum)
2325                return accum;
2326
2327        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
2328                accum += udf_count_free_table(sb,
2329                                              map->s_uspace.s_table);
2330        }
2331        if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
2332                accum += udf_count_free_table(sb,
2333                                              map->s_fspace.s_table);
2334        }
2335
2336        return accum;
2337}
2338
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.