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