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