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