super.c 61 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
/*
 * super.c
 *
 * PURPOSE
 *  Super block routines for the OSTA-UDF(tm) filesystem.
 *
 * DESCRIPTION
 *  OSTA-UDF(tm) = Optical Storage Technology Association
 *  Universal Disk Format.
 *
 *  This code is based on version 2.00 of the UDF specification,
 *  and revision 3 of the ECMA 167 standard [equivalent to ISO 13346].
 *    http://www.osta.org/
 *    http://www.ecma.ch/
 *    http://www.iso.org/
 *
 * COPYRIGHT
 *  This file is distributed under the terms of the GNU General Public
 *  License (GPL). Copies of the GPL can be obtained from:
 *    ftp://prep.ai.mit.edu/pub/gnu/GPL
 *  Each contributing author retains all rights to their own work.
 *
 *  (C) 1998 Dave Boynton
 *  (C) 1998-2004 Ben Fennema
 *  (C) 2000 Stelias Computing Inc
 *
 * HISTORY
 *
 *  09/24/98 dgb  changed to allow compiling outside of kernel, and
 *                added some debugging.
 *  10/01/98 dgb  updated to allow (some) possibility of compiling w/2.0.34
 *  10/16/98      attempting some multi-session support
 *  10/17/98      added freespace count for "df"
 *  11/11/98 gr   added novrs option
 *  11/26/98 dgb  added fileset,anchor mount options
36 37
 *  12/06/98 blf  really hosed things royally. vat/sparing support. sequenced
 *                vol descs. rewrote option handling based on isofs
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40
 *  12/20/98      find the free space bitmap (if it exists)
 */

41
#include "udfdecl.h"
Linus Torvalds's avatar
Linus Torvalds committed
42 43 44 45 46 47 48 49 50 51 52 53 54

#include <linux/blkdev.h>
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/parser.h>
#include <linux/stat.h>
#include <linux/cdrom.h>
#include <linux/nls.h>
#include <linux/smp_lock.h>
#include <linux/buffer_head.h>
#include <linux/vfs.h>
#include <linux/vmalloc.h>
55
#include <linux/errno.h>
Miklos Szeredi's avatar
Miklos Szeredi committed
56
#include <linux/mount.h>
57
#include <linux/quotaops.h>
Miklos Szeredi's avatar
Miklos Szeredi committed
58
#include <linux/seq_file.h>
59
#include <linux/bitmap.h>
60
#include <linux/crc-itu-t.h>
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77
#include <asm/byteorder.h>

#include "udf_sb.h"
#include "udf_i.h"

#include <linux/init.h>
#include <asm/uaccess.h>

#define VDS_POS_PRIMARY_VOL_DESC	0
#define VDS_POS_UNALLOC_SPACE_DESC	1
#define VDS_POS_LOGICAL_VOL_DESC	2
#define VDS_POS_PARTITION_DESC		3
#define VDS_POS_IMP_USE_VOL_DESC	4
#define VDS_POS_VOL_DESC_PTR		5
#define VDS_POS_TERMINATING_DESC	6
#define VDS_POS_LENGTH			7

Miklos Szeredi's avatar
Miklos Szeredi committed
78 79
#define UDF_DEFAULT_BLOCKSIZE 2048

Linus Torvalds's avatar
Linus Torvalds committed
80 81 82 83 84
static char error_buf[1024];

/* These are the "meat" - everything else is stuffing */
static int udf_fill_super(struct super_block *, void *, int);
static void udf_put_super(struct super_block *);
85
static int udf_sync_fs(struct super_block *, int);
Linus Torvalds's avatar
Linus Torvalds committed
86
static int udf_remount_fs(struct super_block *, int *, char *);
87 88 89
static void udf_load_logicalvolint(struct super_block *, struct kernel_extent_ad);
static int udf_find_fileset(struct super_block *, struct kernel_lb_addr *,
			    struct kernel_lb_addr *);
90
static void udf_load_fileset(struct super_block *, struct buffer_head *,
91
			     struct kernel_lb_addr *);
Linus Torvalds's avatar
Linus Torvalds committed
92 93 94
static void udf_open_lvid(struct super_block *);
static void udf_close_lvid(struct super_block *);
static unsigned int udf_count_free(struct super_block *);
95
static int udf_statfs(struct dentry *, struct kstatfs *);
Miklos Szeredi's avatar
Miklos Szeredi committed
96
static int udf_show_options(struct seq_file *, struct vfsmount *);
Adrian Bunk's avatar
Adrian Bunk committed
97 98
static void udf_error(struct super_block *sb, const char *function,
		      const char *fmt, ...);
Linus Torvalds's avatar
Linus Torvalds committed
99

100 101
struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
{
Marcin Slusarz's avatar
Marcin Slusarz committed
102 103
	struct logicalVolIntegrityDesc *lvid =
		(struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
104
	__u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
Marcin Slusarz's avatar
Marcin Slusarz committed
105 106
	__u32 offset = number_of_partitions * 2 *
				sizeof(uint32_t)/sizeof(uint8_t);
107 108 109
	return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
}

Linus Torvalds's avatar
Linus Torvalds committed
110
/* UDF filesystem type */
111
static int udf_get_sb(struct file_system_type *fs_type,
112 113
		      int flags, const char *dev_name, void *data,
		      struct vfsmount *mnt)
Linus Torvalds's avatar
Linus Torvalds committed
114
{
115
	return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt);
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118
}

static struct file_system_type udf_fstype = {
119 120 121 122 123
	.owner		= THIS_MODULE,
	.name		= "udf",
	.get_sb		= udf_get_sb,
	.kill_sb	= kill_block_super,
	.fs_flags	= FS_REQUIRES_DEV,
Linus Torvalds's avatar
Linus Torvalds committed
124 125
};

126
static struct kmem_cache *udf_inode_cachep;
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130

static struct inode *udf_alloc_inode(struct super_block *sb)
{
	struct udf_inode_info *ei;
131
	ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
132 133
	if (!ei)
		return NULL;
134 135 136 137 138 139 140

	ei->i_unique = 0;
	ei->i_lenExtents = 0;
	ei->i_next_alloc_block = 0;
	ei->i_next_alloc_goal = 0;
	ei->i_strat4096 = 0;

Linus Torvalds's avatar
Linus Torvalds committed
141 142 143 144 145 146 147 148
	return &ei->vfs_inode;
}

static void udf_destroy_inode(struct inode *inode)
{
	kmem_cache_free(udf_inode_cachep, UDF_I(inode));
}

149
static void init_once(void *foo)
Linus Torvalds's avatar
Linus Torvalds committed
150
{
151
	struct udf_inode_info *ei = (struct udf_inode_info *)foo;
Linus Torvalds's avatar
Linus Torvalds committed
152

153 154
	ei->i_ext.i_data = NULL;
	inode_init_once(&ei->vfs_inode);
Linus Torvalds's avatar
Linus Torvalds committed
155 156 157 158 159 160
}

static int init_inodecache(void)
{
	udf_inode_cachep = kmem_cache_create("udf_inode_cache",
					     sizeof(struct udf_inode_info),
161 162
					     0, (SLAB_RECLAIM_ACCOUNT |
						 SLAB_MEM_SPREAD),
163
					     init_once);
164
	if (!udf_inode_cachep)
Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168 169 170
		return -ENOMEM;
	return 0;
}

static void destroy_inodecache(void)
{
171
	kmem_cache_destroy(udf_inode_cachep);
Linus Torvalds's avatar
Linus Torvalds committed
172 173 174
}

/* Superblock operations */
175
static const struct super_operations udf_sb_ops = {
176 177 178 179 180 181
	.alloc_inode	= udf_alloc_inode,
	.destroy_inode	= udf_destroy_inode,
	.write_inode	= udf_write_inode,
	.delete_inode	= udf_delete_inode,
	.clear_inode	= udf_clear_inode,
	.put_super	= udf_put_super,
182
	.sync_fs	= udf_sync_fs,
183 184
	.statfs		= udf_statfs,
	.remount_fs	= udf_remount_fs,
Miklos Szeredi's avatar
Miklos Szeredi committed
185
	.show_options	= udf_show_options,
Linus Torvalds's avatar
Linus Torvalds committed
186 187
};

188
struct udf_options {
Linus Torvalds's avatar
Linus Torvalds committed
189 190 191 192 193 194 195 196 197 198 199 200 201
	unsigned char novrs;
	unsigned int blocksize;
	unsigned int session;
	unsigned int lastblock;
	unsigned int anchor;
	unsigned int volume;
	unsigned short partition;
	unsigned int fileset;
	unsigned int rootdir;
	unsigned int flags;
	mode_t umask;
	gid_t gid;
	uid_t uid;
202 203
	mode_t fmode;
	mode_t dmode;
Linus Torvalds's avatar
Linus Torvalds committed
204 205 206 207 208 209
	struct nls_table *nls_map;
};

static int __init init_udf_fs(void)
{
	int err;
210

Linus Torvalds's avatar
Linus Torvalds committed
211 212 213 214 215 216
	err = init_inodecache();
	if (err)
		goto out1;
	err = register_filesystem(&udf_fstype);
	if (err)
		goto out;
217

Linus Torvalds's avatar
Linus Torvalds committed
218
	return 0;
219 220

out:
Linus Torvalds's avatar
Linus Torvalds committed
221
	destroy_inodecache();
222 223

out1:
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226 227 228 229 230 231 232 233
	return err;
}

static void __exit exit_udf_fs(void)
{
	unregister_filesystem(&udf_fstype);
	destroy_inodecache();
}

module_init(init_udf_fs)
234
module_exit(exit_udf_fs)
Linus Torvalds's avatar
Linus Torvalds committed
235

236 237 238 239 240 241 242
static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
{
	struct udf_sb_info *sbi = UDF_SB(sb);

	sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
				  GFP_KERNEL);
	if (!sbi->s_partmaps) {
243
		udf_error(sb, __func__,
244 245 246 247 248 249 250 251 252 253
			  "Unable to allocate space for %d partition maps",
			  count);
		sbi->s_partitions = 0;
		return -ENOMEM;
	}

	sbi->s_partitions = count;
	return 0;
}

Miklos Szeredi's avatar
Miklos Szeredi committed
254 255 256 257 258 259 260
static int udf_show_options(struct seq_file *seq, struct vfsmount *mnt)
{
	struct super_block *sb = mnt->mnt_sb;
	struct udf_sb_info *sbi = UDF_SB(sb);

	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
		seq_puts(seq, ",nostrict");
261
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_BLOCKSIZE_SET))
Miklos Szeredi's avatar
Miklos Szeredi committed
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
		seq_printf(seq, ",bs=%lu", sb->s_blocksize);
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE))
		seq_puts(seq, ",unhide");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE))
		seq_puts(seq, ",undelete");
	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB))
		seq_puts(seq, ",noadinicb");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD))
		seq_puts(seq, ",shortad");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET))
		seq_puts(seq, ",uid=forget");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_IGNORE))
		seq_puts(seq, ",uid=ignore");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET))
		seq_puts(seq, ",gid=forget");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_IGNORE))
		seq_puts(seq, ",gid=ignore");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET))
		seq_printf(seq, ",uid=%u", sbi->s_uid);
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
		seq_printf(seq, ",gid=%u", sbi->s_gid);
	if (sbi->s_umask != 0)
		seq_printf(seq, ",umask=%o", sbi->s_umask);
285
	if (sbi->s_fmode != UDF_INVALID_MODE)
286
		seq_printf(seq, ",mode=%o", sbi->s_fmode);
287
	if (sbi->s_dmode != UDF_INVALID_MODE)
288
		seq_printf(seq, ",dmode=%o", sbi->s_dmode);
Miklos Szeredi's avatar
Miklos Szeredi committed
289 290 291 292
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
		seq_printf(seq, ",session=%u", sbi->s_session);
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
		seq_printf(seq, ",lastblock=%u", sbi->s_last_block);
293 294
	if (sbi->s_anchor != 0)
		seq_printf(seq, ",anchor=%u", sbi->s_anchor);
Miklos Szeredi's avatar
Miklos Szeredi committed
295 296 297 298 299 300 301 302 303 304 305 306
	/*
	 * volume, partition, fileset and rootdir seem to be ignored
	 * currently
	 */
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
		seq_puts(seq, ",utf8");
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP) && sbi->s_nls_map)
		seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset);

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
307 308 309 310 311 312 313 314 315 316 317
/*
 * udf_parse_options
 *
 * PURPOSE
 *	Parse mount options.
 *
 * DESCRIPTION
 *	The following mount options are supported:
 *
 *	gid=		Set the default group.
 *	umask=		Set the default umask.
318 319
 *	mode=		Set the default file permissions.
 *	dmode=		Set the default directory permissions.
Linus Torvalds's avatar
Linus Torvalds committed
320 321 322 323 324 325 326 327 328 329 330 331 332
 *	uid=		Set the default user.
 *	bs=		Set the block size.
 *	unhide		Show otherwise hidden files.
 *	undelete	Show deleted files in lists.
 *	adinicb		Embed data in the inode (default)
 *	noadinicb	Don't embed data in the inode
 *	shortad		Use short ad's
 *	longad		Use long ad's (default)
 *	nostrict	Unset strict conformance
 *	iocharset=	Set the NLS character set
 *
 *	The remaining are for debugging and disaster recovery:
 *
333
 *	novrs		Skip volume sequence recognition
Linus Torvalds's avatar
Linus Torvalds committed
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
 *
 *	The following expect a offset from 0.
 *
 *	session=	Set the CDROM session (default= last session)
 *	anchor=		Override standard anchor location. (default= 256)
 *	volume=		Override the VolumeDesc location. (unused)
 *	partition=	Override the PartitionDesc location. (unused)
 *	lastblock=	Set the last block of the filesystem/
 *
 *	The following expect a offset from the partition root.
 *
 *	fileset=	Override the fileset block location. (unused)
 *	rootdir=	Override the root directory location. (unused)
 *		WARNING: overriding the rootdir to a non-directory may
 *		yield highly unpredictable results.
 *
 * PRE-CONDITIONS
 *	options		Pointer to mount options string.
 *	uopts		Pointer to mount options variable.
 *
 * POST-CONDITIONS
 *	<return>	1	Mount options parsed okay.
 *	<return>	0	Error parsing mount options.
 *
 * HISTORY
 *	July 1, 1997 - Andrew E. Mileski
 *	Written, tested, and released.
 */
362

Linus Torvalds's avatar
Linus Torvalds committed
363 364 365 366 367 368
enum {
	Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete,
	Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad,
	Opt_gid, Opt_uid, Opt_umask, Opt_session, Opt_lastblock,
	Opt_anchor, Opt_volume, Opt_partition, Opt_fileset,
	Opt_rootdir, Opt_utf8, Opt_iocharset,
369 370
	Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore,
	Opt_fmode, Opt_dmode
Linus Torvalds's avatar
Linus Torvalds committed
371 372
};

373
static const match_table_t tokens = {
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
	{Opt_novrs,	"novrs"},
	{Opt_nostrict,	"nostrict"},
	{Opt_bs,	"bs=%u"},
	{Opt_unhide,	"unhide"},
	{Opt_undelete,	"undelete"},
	{Opt_noadinicb,	"noadinicb"},
	{Opt_adinicb,	"adinicb"},
	{Opt_shortad,	"shortad"},
	{Opt_longad,	"longad"},
	{Opt_uforget,	"uid=forget"},
	{Opt_uignore,	"uid=ignore"},
	{Opt_gforget,	"gid=forget"},
	{Opt_gignore,	"gid=ignore"},
	{Opt_gid,	"gid=%u"},
	{Opt_uid,	"uid=%u"},
	{Opt_umask,	"umask=%o"},
	{Opt_session,	"session=%u"},
	{Opt_lastblock,	"lastblock=%u"},
	{Opt_anchor,	"anchor=%u"},
	{Opt_volume,	"volume=%u"},
	{Opt_partition,	"partition=%u"},
	{Opt_fileset,	"fileset=%u"},
	{Opt_rootdir,	"rootdir=%u"},
	{Opt_utf8,	"utf8"},
	{Opt_iocharset,	"iocharset=%s"},
399 400
	{Opt_fmode,     "mode=%o"},
	{Opt_dmode,     "dmode=%o"},
401
	{Opt_err,	NULL}
Linus Torvalds's avatar
Linus Torvalds committed
402 403
};

Miklos Szeredi's avatar
Miklos Szeredi committed
404 405
static int udf_parse_options(char *options, struct udf_options *uopt,
			     bool remount)
Linus Torvalds's avatar
Linus Torvalds committed
406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
{
	char *p;
	int option;

	uopt->novrs = 0;
	uopt->partition = 0xFFFF;
	uopt->session = 0xFFFFFFFF;
	uopt->lastblock = 0;
	uopt->anchor = 0;
	uopt->volume = 0xFFFFFFFF;
	uopt->rootdir = 0xFFFFFFFF;
	uopt->fileset = 0xFFFFFFFF;
	uopt->nls_map = NULL;

	if (!options)
		return 1;

423
	while ((p = strsep(&options, ",")) != NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426 427 428 429
		substring_t args[MAX_OPT_ARGS];
		int token;
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
430 431 432
		switch (token) {
		case Opt_novrs:
			uopt->novrs = 1;
433
			break;
434 435 436 437
		case Opt_bs:
			if (match_int(&args[0], &option))
				return 0;
			uopt->blocksize = option;
438
			uopt->flags |= (1 << UDF_FLAG_BLOCKSIZE_SET);
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
			break;
		case Opt_unhide:
			uopt->flags |= (1 << UDF_FLAG_UNHIDE);
			break;
		case Opt_undelete:
			uopt->flags |= (1 << UDF_FLAG_UNDELETE);
			break;
		case Opt_noadinicb:
			uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB);
			break;
		case Opt_adinicb:
			uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB);
			break;
		case Opt_shortad:
			uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD);
			break;
		case Opt_longad:
			uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD);
			break;
		case Opt_gid:
			if (match_int(args, &option))
				return 0;
			uopt->gid = option;
462
			uopt->flags |= (1 << UDF_FLAG_GID_SET);
463 464 465 466 467
			break;
		case Opt_uid:
			if (match_int(args, &option))
				return 0;
			uopt->uid = option;
468
			uopt->flags |= (1 << UDF_FLAG_UID_SET);
469 470 471 472 473 474 475 476 477 478 479 480 481
			break;
		case Opt_umask:
			if (match_octal(args, &option))
				return 0;
			uopt->umask = option;
			break;
		case Opt_nostrict:
			uopt->flags &= ~(1 << UDF_FLAG_STRICT);
			break;
		case Opt_session:
			if (match_int(args, &option))
				return 0;
			uopt->session = option;
Miklos Szeredi's avatar
Miklos Szeredi committed
482 483
			if (!remount)
				uopt->flags |= (1 << UDF_FLAG_SESSION_SET);
484 485 486 487 488
			break;
		case Opt_lastblock:
			if (match_int(args, &option))
				return 0;
			uopt->lastblock = option;
Miklos Szeredi's avatar
Miklos Szeredi committed
489 490
			if (!remount)
				uopt->flags |= (1 << UDF_FLAG_LASTBLOCK_SET);
491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
			break;
		case Opt_anchor:
			if (match_int(args, &option))
				return 0;
			uopt->anchor = option;
			break;
		case Opt_volume:
			if (match_int(args, &option))
				return 0;
			uopt->volume = option;
			break;
		case Opt_partition:
			if (match_int(args, &option))
				return 0;
			uopt->partition = option;
			break;
		case Opt_fileset:
			if (match_int(args, &option))
				return 0;
			uopt->fileset = option;
			break;
		case Opt_rootdir:
			if (match_int(args, &option))
				return 0;
			uopt->rootdir = option;
			break;
		case Opt_utf8:
			uopt->flags |= (1 << UDF_FLAG_UTF8);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
520
#ifdef CONFIG_UDF_NLS
521 522 523 524
		case Opt_iocharset:
			uopt->nls_map = load_nls(args[0].from);
			uopt->flags |= (1 << UDF_FLAG_NLS_MAP);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
525
#endif
526 527 528 529 530 531 532 533 534 535 536 537
		case Opt_uignore:
			uopt->flags |= (1 << UDF_FLAG_UID_IGNORE);
			break;
		case Opt_uforget:
			uopt->flags |= (1 << UDF_FLAG_UID_FORGET);
			break;
		case Opt_gignore:
			uopt->flags |= (1 << UDF_FLAG_GID_IGNORE);
			break;
		case Opt_gforget:
			uopt->flags |= (1 << UDF_FLAG_GID_FORGET);
			break;
538 539 540 541 542 543 544 545 546 547
		case Opt_fmode:
			if (match_octal(args, &option))
				return 0;
			uopt->fmode = option & 0777;
			break;
		case Opt_dmode:
			if (match_octal(args, &option))
				return 0;
			uopt->dmode = option & 0777;
			break;
548 549 550
		default:
			printk(KERN_ERR "udf: bad mount option \"%s\" "
			       "or missing value\n", p);
Linus Torvalds's avatar
Linus Torvalds committed
551 552 553 554 555 556
			return 0;
		}
	}
	return 1;
}

557
static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
Linus Torvalds's avatar
Linus Torvalds committed
558 559
{
	struct udf_options uopt;
560
	struct udf_sb_info *sbi = UDF_SB(sb);
561
	int error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
562

563 564 565 566
	uopt.flags = sbi->s_flags;
	uopt.uid   = sbi->s_uid;
	uopt.gid   = sbi->s_gid;
	uopt.umask = sbi->s_umask;
567 568
	uopt.fmode = sbi->s_fmode;
	uopt.dmode = sbi->s_dmode;
Linus Torvalds's avatar
Linus Torvalds committed
569

Miklos Szeredi's avatar
Miklos Szeredi committed
570
	if (!udf_parse_options(options, &uopt, true))
Linus Torvalds's avatar
Linus Torvalds committed
571 572
		return -EINVAL;

573
	lock_kernel();
574 575 576 577
	sbi->s_flags = uopt.flags;
	sbi->s_uid   = uopt.uid;
	sbi->s_gid   = uopt.gid;
	sbi->s_umask = uopt.umask;
578 579
	sbi->s_fmode = uopt.fmode;
	sbi->s_dmode = uopt.dmode;
Linus Torvalds's avatar
Linus Torvalds committed
580

581 582
	if (sbi->s_lvid_bh) {
		int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev);
Linus Torvalds's avatar
Linus Torvalds committed
583 584 585 586
		if (write_rev > UDF_MAX_WRITE_VERSION)
			*flags |= MS_RDONLY;
	}

587 588 589 590
	if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
		goto out_unlock;

	if (*flags & MS_RDONLY) {
Linus Torvalds's avatar
Linus Torvalds committed
591
		udf_close_lvid(sb);
592

593
		error = dquot_suspend(sb, -1);
594
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
595 596
		udf_open_lvid(sb);

597 598
		/* mark the fs r/w for quota activity */
		sb->s_flags &= ~MS_RDONLY;
599
		dquot_resume(sb, -1);
600 601 602
	}

out_unlock:
603
	unlock_kernel();
604
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
605 606
}

607 608 609
/* Check Volume Structure Descriptors (ECMA 167 2/9.1) */
/* We also check any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
static loff_t udf_check_vsd(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
610 611
{
	struct volStructDesc *vsd = NULL;
612
	loff_t sector = 32768;
Linus Torvalds's avatar
Linus Torvalds committed
613 614
	int sectorsize;
	struct buffer_head *bh = NULL;
615 616
	int nsr02 = 0;
	int nsr03 = 0;
617
	struct udf_sb_info *sbi;
Linus Torvalds's avatar
Linus Torvalds committed
618

619
	sbi = UDF_SB(sb);
Linus Torvalds's avatar
Linus Torvalds committed
620 621 622 623 624
	if (sb->s_blocksize < sizeof(struct volStructDesc))
		sectorsize = sizeof(struct volStructDesc);
	else
		sectorsize = sb->s_blocksize;

625
	sector += (sbi->s_session << sb->s_blocksize_bits);
Linus Torvalds's avatar
Linus Torvalds committed
626 627

	udf_debug("Starting at sector %u (%ld byte sectors)\n",
628 629
		  (unsigned int)(sector >> sb->s_blocksize_bits),
		  sb->s_blocksize);
Linus Torvalds's avatar
Linus Torvalds committed
630
	/* Process the sequence (if applicable) */
631
	for (; !nsr02 && !nsr03; sector += sectorsize) {
Linus Torvalds's avatar
Linus Torvalds committed
632 633 634 635 636 637 638
		/* Read a block */
		bh = udf_tread(sb, sector >> sb->s_blocksize_bits);
		if (!bh)
			break;

		/* Look for ISO  descriptors */
		vsd = (struct volStructDesc *)(bh->b_data +
639
					      (sector & (sb->s_blocksize - 1)));
Linus Torvalds's avatar
Linus Torvalds committed
640

641
		if (vsd->stdIdent[0] == 0) {
Jan Kara's avatar
Jan Kara committed
642
			brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
643
			break;
644 645
		} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
				    VSD_STD_ID_LEN)) {
646 647 648 649 650
			switch (vsd->structType) {
			case 0:
				udf_debug("ISO9660 Boot Record found\n");
				break;
			case 1:
651 652
				udf_debug("ISO9660 Primary Volume Descriptor "
					  "found\n");
653 654
				break;
			case 2:
655 656
				udf_debug("ISO9660 Supplementary Volume "
					  "Descriptor found\n");
657 658
				break;
			case 3:
659 660
				udf_debug("ISO9660 Volume Partition Descriptor "
					  "found\n");
661 662
				break;
			case 255:
663 664
				udf_debug("ISO9660 Volume Descriptor Set "
					  "Terminator found\n");
665 666 667 668 669
				break;
			default:
				udf_debug("ISO9660 VRS (%u) found\n",
					  vsd->structType);
				break;
Linus Torvalds's avatar
Linus Torvalds committed
670
			}
671 672 673 674 675
		} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01,
				    VSD_STD_ID_LEN))
			; /* nothing */
		else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01,
				    VSD_STD_ID_LEN)) {
Jan Kara's avatar
Jan Kara committed
676
			brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
677
			break;
678 679
		} else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
				    VSD_STD_ID_LEN))
Linus Torvalds's avatar
Linus Torvalds committed
680
			nsr02 = sector;
681 682
		else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
				    VSD_STD_ID_LEN))
Linus Torvalds's avatar
Linus Torvalds committed
683
			nsr03 = sector;
Jan Kara's avatar
Jan Kara committed
684
		brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
685 686 687 688 689 690
	}

	if (nsr03)
		return nsr03;
	else if (nsr02)
		return nsr02;
691
	else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768)
Linus Torvalds's avatar
Linus Torvalds committed
692 693 694 695 696
		return -1;
	else
		return 0;
}

697
static int udf_find_fileset(struct super_block *sb,
698 699
			    struct kernel_lb_addr *fileset,
			    struct kernel_lb_addr *root)
Linus Torvalds's avatar
Linus Torvalds committed
700 701 702 703
{
	struct buffer_head *bh = NULL;
	long lastblock;
	uint16_t ident;
704
	struct udf_sb_info *sbi;
Linus Torvalds's avatar
Linus Torvalds committed
705 706

	if (fileset->logicalBlockNum != 0xFFFFFFFF ||
707
	    fileset->partitionReferenceNum != 0xFFFF) {
708
		bh = udf_read_ptagged(sb, fileset, 0, &ident);
Linus Torvalds's avatar
Linus Torvalds committed
709

710
		if (!bh) {
Linus Torvalds's avatar
Linus Torvalds committed
711
			return 1;
712
		} else if (ident != TAG_IDENT_FSD) {
Jan Kara's avatar
Jan Kara committed
713
			brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
714 715
			return 1;
		}
716

Linus Torvalds's avatar
Linus Torvalds committed
717 718
	}

719
	sbi = UDF_SB(sb);
720 721
	if (!bh) {
		/* Search backwards through the partitions */
722
		struct kernel_lb_addr newfileset;
Linus Torvalds's avatar
Linus Torvalds committed
723

724
/* --> cvg: FIXME - is it reasonable? */
Linus Torvalds's avatar
Linus Torvalds committed
725
		return 1;
726

727
		for (newfileset.partitionReferenceNum = sbi->s_partitions - 1;
728 729 730 731
		     (newfileset.partitionReferenceNum != 0xFFFF &&
		      fileset->logicalBlockNum == 0xFFFFFFFF &&
		      fileset->partitionReferenceNum == 0xFFFF);
		     newfileset.partitionReferenceNum--) {
732 733 734
			lastblock = sbi->s_partmaps
					[newfileset.partitionReferenceNum]
						.s_partition_len;
Linus Torvalds's avatar
Linus Torvalds committed
735 736
			newfileset.logicalBlockNum = 0;

737
			do {
738
				bh = udf_read_ptagged(sb, &newfileset, 0,
739
						      &ident);
740 741
				if (!bh) {
					newfileset.logicalBlockNum++;
Linus Torvalds's avatar
Linus Torvalds committed
742 743 744
					continue;
				}

745 746
				switch (ident) {
				case TAG_IDENT_SBD:
747 748
				{
					struct spaceBitmapDesc *sp;
Marcin Slusarz's avatar
Marcin Slusarz committed
749 750
					sp = (struct spaceBitmapDesc *)
								bh->b_data;
751 752
					newfileset.logicalBlockNum += 1 +
						((le32_to_cpu(sp->numOfBytes) +
Marcin Slusarz's avatar
Marcin Slusarz committed
753 754
						  sizeof(struct spaceBitmapDesc)
						  - 1) >> sb->s_blocksize_bits);
755 756 757
					brelse(bh);
					break;
				}
758
				case TAG_IDENT_FSD:
759 760
					*fileset = newfileset;
					break;
761
				default:
762 763 764 765
					newfileset.logicalBlockNum++;
					brelse(bh);
					bh = NULL;
					break;
Linus Torvalds's avatar
Linus Torvalds committed
766
				}
767 768 769
			} while (newfileset.logicalBlockNum < lastblock &&
				 fileset->logicalBlockNum == 0xFFFFFFFF &&
				 fileset->partitionReferenceNum == 0xFFFF);
Linus Torvalds's avatar
Linus Torvalds committed
770 771 772 773
		}
	}

	if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
774
	     fileset->partitionReferenceNum != 0xFFFF) && bh) {
Linus Torvalds's avatar
Linus Torvalds committed
775
		udf_debug("Fileset at block=%d, partition=%d\n",
776 777
			  fileset->logicalBlockNum,
			  fileset->partitionReferenceNum);
Linus Torvalds's avatar
Linus Torvalds committed
778

779
		sbi->s_partition = fileset->partitionReferenceNum;
Linus Torvalds's avatar
Linus Torvalds committed
780
		udf_load_fileset(sb, bh, root);
Jan Kara's avatar
Jan Kara committed
781
		brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
782 783 784 785 786
		return 0;
	}
	return 1;
}

787
static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
Linus Torvalds's avatar
Linus Torvalds committed
788 789
{
	struct primaryVolDesc *pvoldesc;
790
	struct ustr *instr, *outstr;
791 792
	struct buffer_head *bh;
	uint16_t ident;
793 794 795 796 797 798 799 800 801
	int ret = 1;

	instr = kmalloc(sizeof(struct ustr), GFP_NOFS);
	if (!instr)
		return 1;

	outstr = kmalloc(sizeof(struct ustr), GFP_NOFS);
	if (!outstr)
		goto out1;
802 803 804

	bh = udf_read_tagged(sb, block, block, &ident);
	if (!bh)
805 806
		goto out2;

807
	BUG_ON(ident != TAG_IDENT_PVD);
Linus Torvalds's avatar
Linus Torvalds committed
808 809 810

	pvoldesc = (struct primaryVolDesc *)bh->b_data;

811 812
	if (udf_disk_stamp_to_time(&UDF_SB(sb)->s_record_time,
			      pvoldesc->recordingDateAndTime)) {
813
#ifdef UDFFS_DEBUG
814
		struct timestamp *ts = &pvoldesc->recordingDateAndTime;
815
		udf_debug("recording time %04u/%02u/%02u"
816
			  " %02u:%02u (%x)\n",
817 818 819
			  le16_to_cpu(ts->year), ts->month, ts->day, ts->hour,
			  ts->minute, le16_to_cpu(ts->typeAndTimezone));
#endif
Linus Torvalds's avatar
Linus Torvalds committed
820 821
	}

822 823 824 825
	if (!udf_build_ustr(instr, pvoldesc->volIdent, 32))
		if (udf_CS0toUTF8(outstr, instr)) {
			strncpy(UDF_SB(sb)->s_volume_ident, outstr->u_name,
				outstr->u_len > 31 ? 31 : outstr->u_len);
Marcin Slusarz's avatar
Marcin Slusarz committed
826 827
			udf_debug("volIdent[] = '%s'\n",
					UDF_SB(sb)->s_volume_ident);
Linus Torvalds's avatar
Linus Torvalds committed
828 829
		}

830 831 832
	if (!udf_build_ustr(instr, pvoldesc->volSetIdent, 128))
		if (udf_CS0toUTF8(outstr, instr))
			udf_debug("volSetIdent[] = '%s'\n", outstr->u_name);
833 834

	brelse(bh);
835 836 837 838 839 840
	ret = 0;
out2:
	kfree(outstr);
out1:
	kfree(instr);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
841 842
}

843 844 845 846 847
static int udf_load_metadata_files(struct super_block *sb, int partition)
{
	struct udf_sb_info *sbi = UDF_SB(sb);
	struct udf_part_map *map;
	struct udf_meta_data *mdata;
848
	struct kernel_lb_addr addr;
849 850 851 852 853 854 855 856 857 858 859 860
	int fe_error = 0;

	map = &sbi->s_partmaps[partition];
	mdata = &map->s_type_specific.s_metadata;

	/* metadata address */
	addr.logicalBlockNum =  mdata->s_meta_file_loc;
	addr.partitionReferenceNum = map->s_partition_num;

	udf_debug("Metadata file location: block = %d part = %d\n",
			  addr.logicalBlockNum, addr.partitionReferenceNum);

861
	mdata->s_metadata_fe = udf_iget(sb, &addr);
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882

	if (mdata->s_metadata_fe == NULL) {
		udf_warning(sb, __func__, "metadata inode efe not found, "
				"will try mirror inode.");
		fe_error = 1;
	} else if (UDF_I(mdata->s_metadata_fe)->i_alloc_type !=
		 ICBTAG_FLAG_AD_SHORT) {
		udf_warning(sb, __func__, "metadata inode efe does not have "
			"short allocation descriptors!");
		fe_error = 1;
		iput(mdata->s_metadata_fe);
		mdata->s_metadata_fe = NULL;
	}

	/* mirror file entry */
	addr.logicalBlockNum = mdata->s_mirror_file_loc;
	addr.partitionReferenceNum = map->s_partition_num;

	udf_debug("Mirror metadata file location: block = %d part = %d\n",
			  addr.logicalBlockNum, addr.partitionReferenceNum);

883
	mdata->s_mirror_fe = udf_iget(sb, &addr);
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914

	if (mdata->s_mirror_fe == NULL) {
		if (fe_error) {
			udf_error(sb, __func__, "mirror inode efe not found "
			"and metadata inode is missing too, exiting...");
			goto error_exit;
		} else
			udf_warning(sb, __func__, "mirror inode efe not found,"
					" but metadata inode is OK");
	} else if (UDF_I(mdata->s_mirror_fe)->i_alloc_type !=
		 ICBTAG_FLAG_AD_SHORT) {
		udf_warning(sb, __func__, "mirror inode efe does not have "
			"short allocation descriptors!");
		iput(mdata->s_mirror_fe);
		mdata->s_mirror_fe = NULL;
		if (fe_error)
			goto error_exit;
	}

	/*
	 * bitmap file entry
	 * Note:
	 * Load only if bitmap file location differs from 0xFFFFFFFF (DCN-5102)
	*/
	if (mdata->s_bitmap_file_loc != 0xFFFFFFFF) {
		addr.logicalBlockNum = mdata->s_bitmap_file_loc;
		addr.partitionReferenceNum = map->s_partition_num;

		udf_debug("Bitmap file location: block = %d part = %d\n",
			addr.logicalBlockNum, addr.partitionReferenceNum);

915
		mdata->s_bitmap_fe = udf_iget(sb, &addr);
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937

		if (mdata->s_bitmap_fe == NULL) {
			if (sb->s_flags & MS_RDONLY)
				udf_warning(sb, __func__, "bitmap inode efe "
					"not found but it's ok since the disc"
					" is mounted read-only");
			else {
				udf_error(sb, __func__, "bitmap inode efe not "
					"found and attempted read-write mount");
				goto error_exit;
			}
		}
	}

	udf_debug("udf_load_metadata_files Ok\n");

	return 0;

error_exit:
	return 1;
}

938
static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
939
			     struct kernel_lb_addr *root)
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942 943 944 945 946
{
	struct fileSetDesc *fset;

	fset = (struct fileSetDesc *)bh->b_data;

	*root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);

947
	UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
Linus Torvalds's avatar
Linus Torvalds committed
948

949 950
	udf_debug("Rootdir at block=%d, partition=%d\n",
		  root->logicalBlockNum, root->partitionReferenceNum);
Linus Torvalds's avatar
Linus Torvalds committed
951 952
}

953 954 955
int udf_compute_nr_groups(struct super_block *sb, u32 partition)
{
	struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
Julia Lawall's avatar
Julia Lawall committed
956 957 958
	return DIV_ROUND_UP(map->s_partition_len +
			    (sizeof(struct spaceBitmapDesc) << 3),
			    sb->s_blocksize * 8);
959 960
}

961 962 963 964 965 966
static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
{
	struct udf_bitmap *bitmap;
	int nr_groups;
	int size;

967
	nr_groups = udf_compute_nr_groups(sb, index);
968 969 970 971 972 973 974 975 976
	size = sizeof(struct udf_bitmap) +
		(sizeof(struct buffer_head *) * nr_groups);

	if (size <= PAGE_SIZE)
		bitmap = kmalloc(size, GFP_KERNEL);
	else
		bitmap = vmalloc(size); /* TODO: get rid of vmalloc */

	if (bitmap == NULL) {
977
		udf_error(sb, __func__,
978 979 980 981 982 983 984 985 986 987 988
			  "Unable to allocate space for bitmap "
			  "and %d buffer_head pointers", nr_groups);
		return NULL;
	}

	memset(bitmap, 0x00, size);
	bitmap->s_block_bitmap = (struct buffer_head **)(bitmap + 1);
	bitmap->s_nr_groups = nr_groups;
	return bitmap;
}

989 990
static int udf_fill_partdesc_info(struct super_block *sb,
		struct partitionDesc *p, int p_index)
Linus Torvalds's avatar
Linus Torvalds committed
991
{
992
	struct udf_part_map *map;
Marcin Slusarz's avatar
Marcin Slusarz committed
993
	struct udf_sb_info *sbi = UDF_SB(sb);
994
	struct partitionHeaderDesc *phd;
Marcin Slusarz's avatar
Marcin Slusarz committed
995

996
	map = &sbi->s_partmaps[p_index];
Marcin Slusarz's avatar
Marcin Slusarz committed
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009

	map->s_partition_len = le32_to_cpu(p->partitionLength); /* blocks */
	map->s_partition_root = le32_to_cpu(p->partitionStartingLocation);

	if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY))
		map->s_partition_flags |= UDF_PART_FLAG_READ_ONLY;
	if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE))
		map->s_partition_flags |= UDF_PART_FLAG_WRITE_ONCE;
	if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE))
		map->s_partition_flags |= UDF_PART_FLAG_REWRITABLE;
	if (p->accessType == cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
		map->s_partition_flags |= UDF_PART_FLAG_OVERWRITABLE;

1010 1011
	udf_debug("Partition (%d type %x) starts at physical %d, "
		  "block length %d\n", p_index,
Marcin Slusarz's avatar
Marcin Slusarz committed
1012 1013 1014 1015 1016
		  map->s_partition_type, map->s_partition_root,
		  map->s_partition_len);

	if (strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) &&
	    strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03))
1017
		return 0;
Marcin Slusarz's avatar
Marcin Slusarz committed
1018 1019 1020

	phd = (struct partitionHeaderDesc *)p->partitionContentsUse;
	if (phd->unallocSpaceTable.extLength) {
1021
		struct kernel_lb_addr loc = {
Marcin Slusarz's avatar
Marcin Slusarz committed
1022 1023
			.logicalBlockNum = le32_to_cpu(
				phd->unallocSpaceTable.extPosition),
1024
			.partitionReferenceNum = p_index,
Marcin Slusarz's avatar
Marcin Slusarz committed
1025 1026
		};

1027
		map->s_uspace.s_table = udf_iget(sb, &loc);
Marcin Slusarz's avatar
Marcin Slusarz committed
1028 1029
		if (!map->s_uspace.s_table) {
			udf_debug("cannot load unallocSpaceTable (part %d)\n",
1030 1031
					p_index);
			return 1;
Marcin Slusarz's avatar
Marcin Slusarz committed
1032 1033 1034
		}
		map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
		udf_debug("unallocSpaceTable (part %d) @ %ld\n",
1035
				p_index, map->s_uspace.s_table->i_ino);
Marcin Slusarz's avatar
Marcin Slusarz committed
1036 1037 1038
	}

	if (phd->unallocSpaceBitmap.extLength) {
1039 1040 1041
		struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
		if (!bitmap)
			return 1;
Marcin Slusarz's avatar
Marcin Slusarz committed
1042
		map->s_uspace.s_bitmap = bitmap;
1043
		bitmap->s_extLength = le32_to_cpu(
Marcin Slusarz's avatar
Marcin Slusarz committed
1044
				phd->unallocSpaceBitmap.extLength);
1045
		bitmap->s_extPosition = le32_to_cpu(
Marcin Slusarz's avatar
Marcin Slusarz committed
1046
				phd->unallocSpaceBitmap.extPosition);
1047
		map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
1048
		udf_debug("unallocSpaceBitmap (part %d) @ %d\n", p_index,
1049
						bitmap->s_extPosition);
Marcin Slusarz's avatar
Marcin Slusarz committed
1050 1051 1052
	}

	if (phd->partitionIntegrityTable.extLength)
1053
		udf_debug("partitionIntegrityTable (part %d)\n", p_index);
Marcin Slusarz's avatar
Marcin Slusarz committed
1054 1055

	if (phd->freedSpaceTable.extLength) {
1056
		struct kernel_lb_addr loc = {
Marcin Slusarz's avatar
Marcin Slusarz committed
1057 1058
			.logicalBlockNum = le32_to_cpu(
				phd->freedSpaceTable.extPosition),
1059
			.partitionReferenceNum = p_index,
Marcin Slusarz's avatar
Marcin Slusarz committed
1060 1061
		};

1062
		map->s_fspace.s_table = udf_iget(sb, &loc);
Marcin Slusarz's avatar
Marcin Slusarz committed
1063
		if (!map->s_fspace.s_table) {
1064 1065 1066
			udf_debug("cannot load freedSpaceTable (part %d)\n",
				p_index);
			return 1;
Marcin Slusarz's avatar
Marcin Slusarz committed
1067 1068 1069 1070
		}

		map->s_partition_flags |= UDF_PART_FLAG_FREED_TABLE;
		udf_debug("freedSpaceTable (part %d) @ %ld\n",
1071
				p_index, map->s_fspace.s_table->i_ino);
Marcin Slusarz's avatar
Marcin Slusarz committed
1072 1073 1074
	}

	if (phd->freedSpaceBitmap.extLength) {
1075 1076 1077
		struct udf_bitmap *bitmap = udf_sb_alloc_bitmap(sb, p_index);
		if (!bitmap)
			return 1;
Marcin Slusarz's avatar
Marcin Slusarz committed
1078
		map->s_fspace.s_bitmap = bitmap;
1079
		bitmap->s_extLength = le32_to_cpu(
Marcin Slusarz's avatar
Marcin Slusarz committed
1080
				phd->freedSpaceBitmap.extLength);
1081
		bitmap->s_extPosition = le32_to_cpu(
Marcin Slusarz's avatar
Marcin Slusarz committed
1082
				phd->freedSpaceBitmap.extPosition);
1083
		map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
1084
		udf_debug("freedSpaceBitmap (part %d) @ %d\n", p_index,
1085
					bitmap->s_extPosition);
Marcin Slusarz's avatar
Marcin Slusarz committed
1086
	}
1087 1088 1089
	return 0;
}

1090 1091
static void udf_find_vat_block(struct super_block *sb, int p_index,
			       int type1_index, sector_t start_block)
1092 1093 1094
{
	struct udf_sb_info *sbi = UDF_SB(sb);
	struct udf_part_map *map = &sbi->s_partmaps[p_index];
1095
	sector_t vat_block;
1096
	struct kernel_lb_addr ino;
1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115

	/*
	 * VAT file entry is in the last recorded block. Some broken disks have
	 * it a few blocks before so try a bit harder...
	 */
	ino.partitionReferenceNum = type1_index;
	for (vat_block = start_block;
	     vat_block >= map->s_partition_root &&
	     vat_block >= start_block - 3 &&
	     !sbi->s_vat_inode; vat_block--) {
		ino.logicalBlockNum = vat_block - map->s_partition_root;
		sbi->s_vat_inode = udf_iget(sb, &ino);
	}
}

static int udf_load_vat(struct super_block *sb, int p_index, int type1_index)
{
	struct udf_sb_info *sbi = UDF_SB(sb);
	struct udf_part_map *map = &sbi->s_partmaps[p_index];
1116 1117 1118 1119
	struct buffer_head *bh = NULL;
	struct udf_inode_info *vati;
	uint32_t pos;
	struct virtualAllocationTable20 *vat20;
1120
	sector_t blocks = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
1121

1122
	udf_find_vat_block(sb, p_index, type1_index, sbi->s_last_block);
1123 1124 1125 1126 1127 1128 1129
	if (!sbi->s_vat_inode &&
	    sbi->s_last_block != blocks - 1) {
		printk(KERN_NOTICE "UDF-fs: Failed to read VAT inode from the"
		       " last recorded block (%lu), retrying with the last "
		       "block of the device (%lu).\n",
		       (unsigned long)sbi->s_last_block,
		       (unsigned long)blocks - 1);
1130
		udf_find_vat_block(sb, p_index, type1_index, blocks - 1);
1131
	}
1132 1133 1134 1135
	if (!sbi->s_vat_inode)
		return 1;

	if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
1136
		map->s_type_specific.s_virtual.s_start_offset = 0;
1137 1138 1139
		map->s_type_specific.s_virtual.s_num_entries =
			(sbi->s_vat_inode->i_size - 36) >> 2;
	} else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
		vati = UDF_I(sbi->s_vat_inode);
		if (vati->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
			pos = udf_block_map(sbi->s_vat_inode, 0);
			bh = sb_bread(sb, pos);
			if (!bh)
				return 1;
			vat20 = (struct virtualAllocationTable20 *)bh->b_data;
		} else {
			vat20 = (struct virtualAllocationTable20 *)
							vati->i_ext.i_data;
		}
1151 1152

		map->s_type_specific.s_virtual.s_start_offset =
1153
			le16_to_cpu(vat20->lengthHeader);
1154 1155 1156 1157 1158 1159 1160 1161 1162
		map->s_type_specific.s_virtual.s_num_entries =
			(sbi->s_vat_inode->i_size -
				map->s_type_specific.s_virtual.
					s_start_offset) >> 2;
		brelse(bh);
	}
	return 0;
}

1163 1164 1165 1166 1167 1168
static int udf_load_partdesc(struct super_block *sb, sector_t block)
{
	struct buffer_head *bh;
	struct partitionDesc *p;
	struct udf_part_map *map;
	struct udf_sb_info *sbi = UDF_SB(sb);
1169
	int i, type1_idx;
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
	uint16_t partitionNumber;
	uint16_t ident;
	int ret = 0;

	bh = udf_read_tagged(sb, block, block, &ident);
	if (!bh)
		return 1;
	if (ident != TAG_IDENT_PD)
		goto out_bh;

	p = (struct partitionDesc *)bh->b_data;
	partitionNumber = le16_to_cpu(p->partitionNumber);
1182

1183
	/* First scan for TYPE1, SPARABLE and METADATA partitions */
1184 1185 1186 1187
	for (i = 0; i < sbi->s_partitions; i++) {
		map = &sbi->s_partmaps[i];
		udf_debug("Searching map: (%d == %d)\n",
			  map->s_partition_num, partitionNumber);
1188 1189 1190
		if (map->s_partition_num == partitionNumber &&
		    (map->s_partition_type == UDF_TYPE1_MAP15 ||
		     map->s_partition_type == UDF_SPARABLE_MAP15))
1191 1192 1193
			break;
	}

1194
	if (i >= sbi->s_partitions) {
1195 1196 1197 1198
		udf_debug("Partition (%d) not found in partition map\n",
			  partitionNumber);
		goto out_bh;
	}
Marcin Slusarz's avatar
Marcin Slusarz committed
1199

1200
	ret = udf_fill_partdesc_info(sb, p, i);
1201 1202

	/*
1203 1204
	 * Now rescan for VIRTUAL or METADATA partitions when SPARABLE and
	 * PHYSICAL partitions are already set up
1205 1206 1207 1208 1209 1210 1211
	 */
	type1_idx = i;
	for (i = 0; i < sbi->s_partitions; i++) {
		map = &sbi->s_partmaps[i];

		if (map->s_partition_num == partitionNumber &&
		    (map->s_partition_type == UDF_VIRTUAL_MAP15 ||
1212 1213
		     map->s_partition_type == UDF_VIRTUAL_MAP20 ||
		     map->s_partition_type == UDF_METADATA_MAP25))
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
			break;
	}

	if (i >= sbi->s_partitions)
		goto out_bh;

	ret = udf_fill_partdesc_info(sb, p, i);
	if (ret)
		goto out_bh;

1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
	if (map->s_partition_type == UDF_METADATA_MAP25) {
		ret = udf_load_metadata_files(sb, i);
		if (ret) {
			printk(KERN_ERR "UDF-fs: error loading MetaData "
			"partition map %d\n", i);
			goto out_bh;
		}
	} else {
		ret = udf_load_vat(sb, i, type1_idx);
		if (ret)
			goto out_bh;
		/*
		 * Mark filesystem read-only if we have a partition with
		 * virtual map since we don't handle writing to it (we
		 * overwrite blocks instead of relocating them).
		 */
		sb->s_flags |= MS_RDONLY;
		printk(KERN_NOTICE "UDF-fs: Filesystem marked read-only "
			"because writing to pseudooverwrite partition is "
			"not implemented.\n");
	}
1245
out_bh:
1246
	/* In case loading failed, we handle cleanup in udf_fill_super */
1247 1248
	brelse(bh);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1249 1250
}

1251
static int udf_load_logicalvol(struct super_block *sb, sector_t block,
1252
			       struct kernel_lb_addr *fileset)
Linus Torvalds's avatar
Linus Torvalds committed
1253 1254 1255 1256
{
	struct logicalVolDesc *lvd;
	int i, j, offset;
	uint8_t type;
1257
	struct udf_sb_info *sbi = UDF_SB(sb);
Marcin Slusarz's avatar
Marcin Slusarz committed
1258
	struct genericPartitionMap *gpm;
1259 1260 1261
	uint16_t ident;
	struct buffer_head *bh;
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1262

1263 1264 1265 1266
	bh = udf_read_tagged(sb, block, block, &ident);
	if (!bh)
		return 1;
	BUG_ON(ident != TAG_IDENT_LVD);
Linus Torvalds's avatar
Linus Torvalds committed
1267 1268
	lvd = (struct logicalVolDesc *)bh->b_data;

1269
	i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
1270 1271 1272 1273
	if (i != 0) {
		ret = i;
		goto out_bh;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1274

1275
	for (i = 0, offset = 0;
1276
	     i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
Marcin Slusarz's avatar
Marcin Slusarz committed
1277 1278 1279 1280 1281
	     i++, offset += gpm->partitionMapLength) {
		struct udf_part_map *map = &sbi->s_partmaps[i];
		gpm = (struct genericPartitionMap *)
				&(lvd->partitionMaps[offset]);
		type = gpm->partitionMapType;
1282
		if (type == 1) {
Marcin Slusarz's avatar
Marcin Slusarz committed
1283 1284
			struct genericPartitionMap1 *gpm1 =
				(struct genericPartitionMap1 *)gpm;
1285 1286 1287 1288
			map->s_partition_type = UDF_TYPE1_MAP15;
			map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum);
			map->s_partition_num = le16_to_cpu(gpm1->partitionNum);
			map->s_partition_func = NULL;
1289
		} else if (type == 2) {
Marcin Slusarz's avatar
Marcin Slusarz committed
1290 1291 1292 1293 1294 1295 1296
			struct udfPartitionMap2 *upm2 =
						(struct udfPartitionMap2 *)gpm;
			if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL,
						strlen(UDF_ID_VIRTUAL))) {
				u16 suf =
					le16_to_cpu(((__le16 *)upm2->partIdent.
							identSuffix)[0]);
Jan Kara's avatar
Jan Kara committed
1297
				if (suf < 0x0200) {
Marcin Slusarz's avatar
Marcin Slusarz committed
1298 1299 1300 1301
					map->s_partition_type =
							UDF_VIRTUAL_MAP15;
					map->s_partition_func =
							udf_get_pblock_virt15;
Jan Kara's avatar
Jan Kara committed
1302
				} else {
Marcin Slusarz's avatar
Marcin Slusarz committed
1303 1304 1305 1306
					map->s_partition_type =
							UDF_VIRTUAL_MAP20;
					map->s_partition_func =
							udf_get_pblock_virt20;
Linus Torvalds's avatar
Linus Torvalds committed
1307
				}
Marcin Slusarz's avatar
Marcin Slusarz committed
1308 1309 1310
			} else if (!strncmp(upm2->partIdent.ident,
						UDF_ID_SPARABLE,
						strlen(UDF_ID_SPARABLE))) {
Linus Torvalds's avatar
Linus Torvalds committed
1311 1312
				uint32_t loc;
				struct sparingTable *st;
Marcin Slusarz's avatar
Marcin Slusarz committed
1313 1314
				struct sparablePartitionMap *spm =
					(struct sparablePartitionMap *)gpm;
1315

1316
				map->s_partition_type = UDF_SPARABLE_MAP15;
Marcin Slusarz's avatar
Marcin Slusarz committed
1317 1318
				map->s_type_specific.s_sparing.s_packet_len =
						le16_to_cpu(spm->packetLength);
1319
				for (j = 0; j < spm->numSparingTables; j++) {
Marcin Slusarz's avatar
Marcin Slusarz committed
1320 1321 1322 1323 1324 1325 1326 1327 1328
					struct buffer_head *bh2;

					loc = le32_to_cpu(
						spm->locSparingTable[j]);
					bh2 = udf_read_tagged(sb, loc, loc,
							     &ident);
					map->s_type_specific.s_sparing.
							s_spar_map[j] = bh2;

Marcin Slusarz's avatar
Marcin Slusarz committed
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
					if (bh2 == NULL)
						continue;

					st = (struct sparingTable *)bh2->b_data;
					if (ident != 0 || strncmp(
						st->sparingIdent.ident,
						UDF_ID_SPARING,
						strlen(UDF_ID_SPARING))) {
						brelse(bh2);
						map->s_type_specific.s_sparing.
							s_spar_map[j] = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1340 1341
					}
				}
1342
				map->s_partition_func = udf_get_pblock_spar15;
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
			} else if (!strncmp(upm2->partIdent.ident,
						UDF_ID_METADATA,
						strlen(UDF_ID_METADATA))) {
				struct udf_meta_data *mdata =
					&map->s_type_specific.s_metadata;
				struct metadataPartitionMap *mdm =
						(struct metadataPartitionMap *)
						&(lvd->partitionMaps[offset]);
				udf_debug("Parsing Logical vol part %d "
					"type %d  id=%s\n", i, type,
					UDF_ID_METADATA);

				map->s_partition_type = UDF_METADATA_MAP25;
				map->s_partition_func = udf_get_pblock_meta25;

				mdata->s_meta_file_loc   =
					le32_to_cpu(mdm->metadataFileLoc);
				mdata->s_mirror_file_loc =
					le32_to_cpu(mdm->metadataMirrorFileLoc);
				mdata->s_bitmap_file_loc =
					le32_to_cpu(mdm->metadataBitmapFileLoc);
				mdata->s_alloc_unit_size =
					le32_to_cpu(mdm->allocUnitSize);
				mdata->s_align_unit_size =
					le16_to_cpu(mdm->alignUnitSize);
				mdata->s_dup_md_flag 	 =
					mdm->flags & 0x01;

				udf_debug("Metadata Ident suffix=0x%x\n",
					(le16_to_cpu(
					 ((__le16 *)
					      mdm->partIdent.identSuffix)[0])));
				udf_debug("Metadata part num=%d\n",
					le16_to_cpu(mdm->partitionNum));
				udf_debug("Metadata part alloc unit size=%d\n",
					le32_to_cpu(mdm->allocUnitSize));
				udf_debug("Metadata file loc=%d\n",
					le32_to_cpu(mdm->metadataFileLoc));
				udf_debug("Mirror file loc=%d\n",
				       le32_to_cpu(mdm->metadataMirrorFileLoc));
				udf_debug("Bitmap file loc=%d\n",
				       le32_to_cpu(mdm->metadataBitmapFileLoc));
				udf_debug("Duplicate Flag: %d %d\n",
					mdata->s_dup_md_flag, mdm->flags);
1387
			} else {
1388 1389
				udf_debug("Unknown ident: %s\n",
					  upm2->partIdent.ident);
Linus Torvalds's avatar
Linus Torvalds committed
1390 1391
				continue;
			}
1392 1393
			map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
			map->s_partition_num = le16_to_cpu(upm2->partitionNum);
Linus Torvalds's avatar
Linus Torvalds committed
1394 1395
		}
		udf_debug("Partition (%d:%d) type %d on volume %d\n",
1396 1397
			  i, map->s_partition_num, type,
			  map->s_volumeseqnum);
Linus Torvalds's avatar
Linus Torvalds committed
1398 1399
	}

1400
	if (fileset) {
1401
		struct long_ad *la = (struct long_ad *)&(lvd->logicalVolContentsUse[0]);
Linus Torvalds's avatar
Linus Torvalds committed
1402 1403

		*fileset = lelb_to_cpu(la->extLocation);
1404 1405
		udf_debug("FileSet found in LogicalVolDesc at block=%d, "
			  "partition=%d\n", fileset->logicalBlockNum,
1406
			  fileset->partitionReferenceNum);
Linus Torvalds's avatar
Linus Torvalds committed
1407 1408 1409
	}
	if (lvd->integritySeqExt.extLength)
		udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
1410

1411 1412 1413
out_bh:
	brelse(bh);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1414 1415 1416 1417 1418 1419
}

/*
 * udf_load_logicalvolint
 *
 */
1420
static void udf_load_logicalvolint(struct super_block *sb, struct kernel_extent_ad loc)
Linus Torvalds's avatar
Linus Torvalds committed
1421 1422 1423
{
	struct buffer_head *bh = NULL;
	uint16_t ident;
1424 1425
	struct udf_sb_info *sbi = UDF_SB(sb);
	struct logicalVolIntegrityDesc *lvid;
Linus Torvalds's avatar
Linus Torvalds committed
1426 1427

	while (loc.extLength > 0 &&
1428 1429 1430
	       (bh = udf_read_tagged(sb, loc.extLocation,
				     loc.extLocation, &ident)) &&
	       ident == TAG_IDENT_LVID) {
1431 1432
		sbi->s_lvid_bh = bh;
		lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
1433

1434
		if (lvid->nextIntegrityExt.extLength)
1435
			udf_load_logicalvolint(sb,
1436
				leea_to_cpu(lvid->nextIntegrityExt));
1437

1438
		if (sbi->s_lvid_bh != bh)
Jan Kara's avatar
Jan Kara committed
1439
			brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
1440
		loc.extLength -= sb->s_blocksize;
1441
		loc.extLocation++;
Linus Torvalds's avatar
Linus Torvalds committed
1442
	}
1443
	if (sbi->s_lvid_bh != bh)
Jan Kara's avatar
Jan Kara committed
1444
		brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461
}

/*
 * udf_process_sequence
 *
 * PURPOSE
 *	Process a main/reserve volume descriptor sequence.
 *
 * PRE-CONDITIONS
 *	sb			Pointer to _locked_ superblock.
 *	block			First block of first extent of the sequence.
 *	lastblock		Lastblock of first extent of the sequence.
 *
 * HISTORY
 *	July 1, 1997 - Andrew E. Mileski
 *	Written, tested, and released.
 */
1462
static noinline int udf_process_sequence(struct super_block *sb, long block,
1463
				long lastblock, struct kernel_lb_addr *fileset)
Linus Torvalds's avatar
Linus Torvalds committed
1464 1465 1466
{
	struct buffer_head *bh = NULL;
	struct udf_vds_record vds[VDS_POS_LENGTH];
Marcin Slusarz's avatar
Marcin Slusarz committed
1467
	struct udf_vds_record *curr;
Linus Torvalds's avatar
Linus Torvalds committed
1468 1469
	struct generic_desc *gd;
	struct volDescPtr *vdp;
1470
	int done = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1471 1472 1473 1474 1475 1476
	uint32_t vdsn;
	uint16_t ident;
	long next_s = 0, next_e = 0;

	memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);

1477 1478 1479 1480
	/*
	 * Read the main descriptor sequence and find which descriptors
	 * are in it.
	 */
1481
	for (; (!done && block <= lastblock); block++) {
Linus Torvalds's avatar
Linus Torvalds committed
1482 1483

		bh = udf_read_tagged(sb, block, block, &ident);
1484 1485 1486 1487 1488 1489
		if (!bh) {
			printk(KERN_ERR "udf: Block %Lu of volume descriptor "
			       "sequence is corrupted or we could not read "
			       "it.\n", (unsigned long long)block);
			return 1;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1490 1491 1492 1493

		/* Process each descriptor (ISO 13346 3/8.3-8.4) */
		gd = (struct generic_desc *)bh->b_data;
		vdsn = le32_to_cpu(gd->volDescSeqNum);
1494
		switch (ident) {
1495
		case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
Marcin Slusarz's avatar
Marcin Slusarz committed
1496 1497 1498 1499
			curr = &vds[VDS_POS_PRIMARY_VOL_DESC];
			if (vdsn >= curr->volDescSeqNum) {
				curr->volDescSeqNum = vdsn;
				curr->block = block;
1500 1501
			}
			break;
1502
		case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
Marcin Slusarz's avatar
Marcin Slusarz committed
1503 1504 1505 1506
			curr = &vds[VDS_POS_VOL_DESC_PTR];
			if (vdsn >= curr->volDescSeqNum) {
				curr->volDescSeqNum = vdsn;
				curr->block = block;
1507 1508

				vdp = (struct volDescPtr *)bh->b_data;
Marcin Slusarz's avatar
Marcin Slusarz committed
1509 1510 1511 1512
				next_s = le32_to_cpu(
					vdp->nextVolDescSeqExt.extLocation);
				next_e = le32_to_cpu(
					vdp->nextVolDescSeqExt.extLength);
1513 1514 1515 1516
				next_e = next_e >> sb->s_blocksize_bits;
				next_e += next_s;
			}
			break;
1517
		case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
Marcin Slusarz's avatar
Marcin Slusarz committed
1518 1519 1520 1521
			curr = &vds[VDS_POS_IMP_USE_VOL_DESC];
			if (vdsn >= curr->volDescSeqNum) {
				curr->volDescSeqNum = vdsn;
				curr->block = block;
1522 1523
			}
			break;
1524
		case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
Marcin Slusarz's avatar
Marcin Slusarz committed
1525 1526 1527
			curr = &vds[VDS_POS_PARTITION_DESC];
			if (!curr->block)
				curr->block = block;
1528
			break;
1529
		case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
Marcin Slusarz's avatar
Marcin Slusarz committed
1530 1531 1532 1533
			curr = &vds[VDS_POS_LOGICAL_VOL_DESC];
			if (vdsn >= curr->volDescSeqNum) {
				curr->volDescSeqNum = vdsn;
				curr->block = block;
1534 1535
			}
			break;
1536
		case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
Marcin Slusarz's avatar
Marcin Slusarz committed
1537 1538 1539 1540
			curr = &vds[VDS_POS_UNALLOC_SPACE_DESC];
			if (vdsn >= curr->volDescSeqNum) {
				curr->volDescSeqNum = vdsn;
				curr->block = block;
1541 1542
			}
			break;
1543
		case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
1544 1545 1546 1547 1548
			vds[VDS_POS_TERMINATING_DESC].block = block;
			if (next_e) {
				block = next_s;
				lastblock = next_e;
				next_s = next_e = 0;
Marcin Slusarz's avatar
Marcin Slusarz committed
1549
			} else
1550 1551
				done = 1;
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1552
		}
Jan Kara's avatar
Jan Kara committed
1553
		brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
1554
	}
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
	/*
	 * Now read interesting descriptors again and process them
	 * in a suitable order
	 */
	if (!vds[VDS_POS_PRIMARY_VOL_DESC].block) {
		printk(KERN_ERR "udf: Primary Volume Descriptor not found!\n");
		return 1;
	}
	if (udf_load_pvoldesc(sb, vds[VDS_POS_PRIMARY_VOL_DESC].block))
		return 1;
Marcin Slusarz's avatar
Marcin Slusarz committed
1565

1566 1567 1568
	if (vds[VDS_POS_LOGICAL_VOL_DESC].block && udf_load_logicalvol(sb,
	    vds[VDS_POS_LOGICAL_VOL_DESC].block, fileset))
		return 1;
Marcin Slusarz's avatar
Marcin Slusarz committed
1569

1570 1571 1572 1573 1574 1575 1576 1577 1578
	if (vds[VDS_POS_PARTITION_DESC].block) {
		/*
		 * We rescan the whole descriptor sequence to find
		 * partition descriptor blocks and process them.
		 */
		for (block = vds[VDS_POS_PARTITION_DESC].block;
		     block < vds[VDS_POS_TERMINATING_DESC].block;
		     block++)
			if (udf_load_partdesc(sb, block))
Marcin Slusarz's avatar
Marcin Slusarz committed
1579
				return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1580 1581 1582 1583 1584
	}

	return 0;
}

1585 1586
static int udf_load_sequence(struct super_block *sb, struct buffer_head *bh,
			     struct kernel_lb_addr *fileset)
Linus Torvalds's avatar
Linus Torvalds committed
1587
{
1588 1589 1590
	struct anchorVolDescPtr *anchor;
	long main_s, main_e, reserve_s, reserve_e;
	struct udf_sb_info *sbi;
Linus Torvalds's avatar
Linus Torvalds committed
1591

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
	sbi = UDF_SB(sb);
	anchor = (struct anchorVolDescPtr *)bh->b_data;

	/* Locate the main sequence */
	main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
	main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
	main_e = main_e >> sb->s_blocksize_bits;
	main_e += main_s;

	/* Locate the reserve sequence */
	reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
	reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
	reserve_e = reserve_e >> sb->s_blocksize_bits;
	reserve_e += reserve_s;

	/* Process the main & reserve sequences */
	/* responsible for finding the PartitionDesc(s) */
	if (!udf_process_sequence(sb, main_s, main_e, fileset))
		return 1;
	return !udf_process_sequence(sb, reserve_s, reserve_e, fileset);
Linus Torvalds's avatar
Linus Torvalds committed
1612 1613
}

1614 1615 1616 1617 1618 1619
/*
 * Check whether there is an anchor block in the given block and
 * load Volume Descriptor Sequence if so.
 */
static int udf_check_anchor_block(struct super_block *sb, sector_t block,
				  struct kernel_lb_addr *fileset)
1620
{
1621 1622 1623
	struct buffer_head *bh;
	uint16_t ident;
	int ret;
1624

1625 1626 1627
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV) &&
	    udf_fixed_to_variable(block) >=
	    sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits)
1628
		return 0;
1629 1630 1631

	bh = udf_read_tagged(sb, block, block, &ident);
	if (!bh)
1632
		return 0;
1633 1634
	if (ident != TAG_IDENT_AVDP) {
		brelse(bh);
1635 1636
		return 0;
	}
1637 1638 1639
	ret = udf_load_sequence(sb, bh, fileset);
	brelse(bh);
	return ret;
1640 1641
}

1642 1643 1644
/* Search for an anchor volume descriptor pointer */
static sector_t udf_scan_anchors(struct super_block *sb, sector_t lastblock,
				 struct kernel_lb_addr *fileset)
Linus Torvalds's avatar
Linus Torvalds committed
1645
{
1646
	sector_t last[6];
1647
	int i;
1648 1649
	struct udf_sb_info *sbi = UDF_SB(sb);
	int last_count = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1650

1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
	/* First try user provided anchor */
	if (sbi->s_anchor) {
		if (udf_check_anchor_block(sb, sbi->s_anchor, fileset))
			return lastblock;
	}
	/*
	 * according to spec, anchor is in either:
	 *     block 256
	 *     lastblock-256
	 *     lastblock
	 *  however, if the disc isn't closed, it could be 512.
	 */
	if (udf_check_anchor_block(sb, sbi->s_session + 256, fileset))
		return lastblock;
	/*
	 * The trouble is which block is the last one. Drives often misreport
	 * this so we try various possibilities.
	 */
	last[last_count++] = lastblock;
	if (lastblock >= 1)
		last[last_count++] = lastblock - 1;
	last[last_count++] = lastblock + 1;
	if (lastblock >= 2)
		last[last_count++] = lastblock - 2;
	if (lastblock >= 150)
		last[last_count++] = lastblock - 150;
	if (lastblock >= 152)
		last[last_count++] = lastblock - 152;
Linus Torvalds's avatar
Linus Torvalds committed
1679

1680 1681 1682
	for (i = 0; i < last_count; i++) {
		if (last[i] >= sb->s_bdev->bd_inode->i_size >>
				sb->s_blocksize_bits)
1683
			continue;
1684 1685 1686
		if (udf_check_anchor_block(sb, last[i], fileset))
			return last[i];
		if (last[i] < 256)
1687
			continue;
1688 1689 1690
		if (udf_check_anchor_block(sb, last[i] - 256, fileset))
			return last[i];
	}
1691

1692 1693 1694 1695 1696
	/* Finally try block 512 in case media is open */
	if (udf_check_anchor_block(sb, sbi->s_session + 512, fileset))
		return last[0];
	return 0;
}
1697

1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710
/*
 * Find an anchor volume descriptor and load Volume Descriptor Sequence from
 * area specified by it. The function expects sbi->s_lastblock to be the last
 * block on the media.
 *
 * Return 1 if ok, 0 if not found.
 *
 */
static int udf_find_anchor(struct super_block *sb,
			   struct kernel_lb_addr *fileset)
{
	sector_t lastblock;
	struct udf_sb_info *sbi = UDF_SB(sb);
1711

1712 1713 1714
	lastblock = udf_scan_anchors(sb, sbi->s_last_block, fileset);
	if (lastblock)
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1715

1716 1717 1718 1719 1720 1721 1722 1723
	/* No anchor found? Try VARCONV conversion of block numbers */
	UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
	/* Firstly, we try to not convert number of the last block */
	lastblock = udf_scan_anchors(sb,
				udf_variable_to_fixed(sbi->s_last_block),
				fileset);
	if (lastblock)
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1724

1725 1726 1727 1728 1729 1730
	/* Secondly, we try with converted number of the last block */
	lastblock = udf_scan_anchors(sb, sbi->s_last_block, fileset);
	if (!lastblock) {
		/* VARCONV didn't help. Clear it. */
		UDF_CLEAR_FLAG(sb, UDF_FLAG_VARCONV);
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1731
	}
1732 1733 1734 1735
out:
	sbi->s_last_block = lastblock;
	return 1;
}
Linus Torvalds's avatar
Linus Torvalds committed
1736

1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
/*
 * Check Volume Structure Descriptor, find Anchor block and load Volume
 * Descriptor Sequence
 */
static int udf_load_vrs(struct super_block *sb, struct udf_options *uopt,
			int silent, struct kernel_lb_addr *fileset)
{
	struct udf_sb_info *sbi = UDF_SB(sb);
	loff_t nsr_off;

	if (!sb_set_blocksize(sb, uopt->blocksize)) {
		if (!silent)
			printk(KERN_WARNING "UDF-fs: Bad block size\n");
		return 0;
	}
	sbi->s_last_block = uopt->lastblock;
	if (!uopt->novrs) {
		/* Check that it is NSR02 compliant */
		nsr_off = udf_check_vsd(sb);
		if (!nsr_off) {
			if (!silent)
				printk(KERN_WARNING "UDF-fs: No VRS found\n");
			return 0;
		}
		if (nsr_off == -1)
			udf_debug("Failed to read byte 32768. Assuming open "
				  "disc. Skipping validity check\n");
		if (!sbi->s_last_block)
			sbi->s_last_block = udf_get_last_block(sb);
	} else {
		udf_debug("Validity check skipped because of novrs option\n");
1768
	}
Linus Torvalds's avatar
Linus Torvalds committed
1769

1770 1771 1772 1773 1774 1775 1776 1777
	/* Look for anchor block and load Volume Descriptor Sequence */
	sbi->s_anchor = uopt->anchor;
	if (!udf_find_anchor(sb, fileset)) {
		if (!silent)
			printk(KERN_WARNING "UDF-fs: No anchor found\n");
		return 0;
	}
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
1778 1779 1780 1781
}

static void udf_open_lvid(struct super_block *sb)
{
1782 1783
	struct udf_sb_info *sbi = UDF_SB(sb);
	struct buffer_head *bh = sbi->s_lvid_bh;
Marcin Slusarz's avatar
Marcin Slusarz committed
1784 1785
	struct logicalVolIntegrityDesc *lvid;
	struct logicalVolIntegrityDescImpUse *lvidiu;
1786

Marcin Slusarz's avatar
Marcin Slusarz committed
1787 1788 1789 1790 1791 1792 1793 1794 1795
	if (!bh)
		return;
	lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
	lvidiu = udf_sb_lvidiu(sbi);

	lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
	lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
	udf_time_to_disk_stamp(&lvid->recordingDateAndTime,
				CURRENT_TIME);
1796
	lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_OPEN);
Marcin Slusarz's avatar
Marcin Slusarz committed
1797 1798

	lvid->descTag.descCRC = cpu_to_le16(
1799
		crc_itu_t(0, (char *)lvid + sizeof(struct tag),
1800
			le16_to_cpu(lvid->descTag.descCRCLength)));
Marcin Slusarz's avatar
Marcin Slusarz committed
1801 1802 1803

	lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
	mark_buffer_dirty(bh);
1804
	sbi->s_lvid_dirty = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1805 1806 1807 1808
}

static void udf_close_lvid(struct super_block *sb)
{
1809 1810 1811
	struct udf_sb_info *sbi = UDF_SB(sb);
	struct buffer_head *bh = sbi->s_lvid_bh;
	struct logicalVolIntegrityDesc *lvid;
Marcin Slusarz's avatar
Marcin Slusarz committed
1812
	struct logicalVolIntegrityDescImpUse *lvidiu;
1813

1814 1815 1816 1817
	if (!bh)
		return;

	lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
Marcin Slusarz's avatar
Marcin Slusarz committed
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
	lvidiu = udf_sb_lvidiu(sbi);
	lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
	lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
	udf_time_to_disk_stamp(&lvid->recordingDateAndTime, CURRENT_TIME);
	if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))
		lvidiu->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
	if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev))
		lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev);
	if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev))
		lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev);
	lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);

	lvid->descTag.descCRC = cpu_to_le16(
1831
			crc_itu_t(0, (char *)lvid + sizeof(struct tag),
1832
				le16_to_cpu(lvid->descTag.descCRCLength)));
Marcin Slusarz's avatar
Marcin Slusarz committed
1833 1834 1835

	lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
	mark_buffer_dirty(bh);
1836
	sbi->s_lvid_dirty = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1837 1838
}

1839 1840 1841 1842
static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
{
	int i;
	int nr_groups = bitmap->s_nr_groups;
Marcin Slusarz's avatar
Marcin Slusarz committed
1843 1844
	int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
						nr_groups);
1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855

	for (i = 0; i < nr_groups; i++)
		if (bitmap->s_block_bitmap[i])
			brelse(bitmap->s_block_bitmap[i]);

	if (size <= PAGE_SIZE)
		kfree(bitmap);
	else
		vfree(bitmap);
}

1856 1857 1858
static void udf_free_partition(struct udf_part_map *map)
{
	int i;
1859
	struct udf_meta_data *mdata;
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871

	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
		iput(map->s_uspace.s_table);
	if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
		iput(map->s_fspace.s_table);
	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
		udf_sb_free_bitmap(map->s_uspace.s_bitmap);
	if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
		udf_sb_free_bitmap(map->s_fspace.s_bitmap);
	if (map->s_partition_type == UDF_SPARABLE_MAP15)
		for (i = 0; i < 4; i++)
			brelse(map->s_type_specific.s_sparing.s_spar_map[i]);
1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
	else if (map->s_partition_type == UDF_METADATA_MAP25) {
		mdata = &map->s_type_specific.s_metadata;
		iput(mdata->s_metadata_fe);
		mdata->s_metadata_fe = NULL;

		iput(mdata->s_mirror_fe);
		mdata->s_mirror_fe = NULL;

		iput(mdata->s_bitmap_fe);
		mdata->s_bitmap_fe = NULL;
	}
1883 1884
}

Linus Torvalds's avatar
Linus Torvalds committed
1885 1886 1887
static int udf_fill_super(struct super_block *sb, void *options, int silent)
{
	int i;
1888
	int ret;
1889
	struct inode *inode = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1890
	struct udf_options uopt;
1891
	struct kernel_lb_addr rootdir, fileset;
Linus Torvalds's avatar
Linus Torvalds committed
1892 1893 1894 1895 1896 1897
	struct udf_sb_info *sbi;

	uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
	uopt.uid = -1;
	uopt.gid = -1;
	uopt.umask = 0;
1898 1899
	uopt.fmode = UDF_INVALID_MODE;
	uopt.dmode = UDF_INVALID_MODE;
Linus Torvalds's avatar
Linus Torvalds committed
1900

1901
	sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
1902 1903
	if (!sbi)
		return -ENOMEM;
1904

Linus Torvalds's avatar
Linus Torvalds committed
1905 1906
	sb->s_fs_info = sbi;

Ingo Molnar's avatar
Ingo Molnar committed
1907
	mutex_init(&sbi->s_alloc_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1908

Miklos Szeredi's avatar
Miklos Szeredi committed
1909
	if (!udf_parse_options((char *)options, &uopt, false))
Linus Torvalds's avatar
Linus Torvalds committed
1910 1911 1912
		goto error_out;

	if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
1913
	    uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
Linus Torvalds's avatar
Linus Torvalds committed
1914
		udf_error(sb, "udf_read_super",
1915
			  "utf8 cannot be combined with iocharset\n");
Linus Torvalds's avatar
Linus Torvalds committed
1916 1917 1918
		goto error_out;
	}
#ifdef CONFIG_UDF_NLS
1919
	if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) {
Linus Torvalds's avatar
Linus Torvalds committed
1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
		uopt.nls_map = load_nls_default();
		if (!uopt.nls_map)
			uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP);
		else
			udf_debug("Using default NLS map\n");
	}
#endif
	if (!(uopt.flags & (1 << UDF_FLAG_NLS_MAP)))
		uopt.flags |= (1 << UDF_FLAG_UTF8);

	fileset.logicalBlockNum = 0xFFFFFFFF;
	fileset.partitionReferenceNum = 0xFFFF;

1933 1934 1935 1936
	sbi->s_flags = uopt.flags;
	sbi->s_uid = uopt.uid;
	sbi->s_gid = uopt.gid;
	sbi->s_umask = uopt.umask;
1937 1938
	sbi->s_fmode = uopt.fmode;
	sbi->s_dmode = uopt.dmode;
1939
	sbi->s_nls_map = uopt.nls_map;
Linus Torvalds's avatar
Linus Torvalds committed
1940

1941
	if (uopt.session == 0xFFFFFFFF)
1942
		sbi->s_session = udf_get_last_session(sb);
Linus Torvalds's avatar
Linus Torvalds committed
1943
	else
1944
		sbi->s_session = uopt.session;
Linus Torvalds's avatar
Linus Torvalds committed
1945

1946
	udf_debug("Multi-session=%d\n", sbi->s_session);
Linus Torvalds's avatar
Linus Torvalds committed
1947

1948 1949 1950 1951 1952 1953 1954 1955
	/* Fill in the rest of the superblock */
	sb->s_op = &udf_sb_ops;
	sb->s_export_op = &udf_export_ops;
	sb->dq_op = NULL;
	sb->s_dirt = 0;
	sb->s_magic = UDF_SUPER_MAGIC;
	sb->s_time_gran = 1000;

1956
	if (uopt.flags & (1 << UDF_FLAG_BLOCKSIZE_SET)) {
1957
		ret = udf_load_vrs(sb, &uopt, silent, &fileset);
1958
	} else {
1959
		uopt.blocksize = bdev_logical_block_size(sb->s_bdev);
1960 1961
		ret = udf_load_vrs(sb, &uopt, silent, &fileset);
		if (!ret && uopt.blocksize != UDF_DEFAULT_BLOCKSIZE) {
1962 1963 1964 1965 1966
			if (!silent)
				printk(KERN_NOTICE
				       "UDF-fs: Rescanning with blocksize "
				       "%d\n", UDF_DEFAULT_BLOCKSIZE);
			uopt.blocksize = UDF_DEFAULT_BLOCKSIZE;
1967
			ret = udf_load_vrs(sb, &uopt, silent, &fileset);
1968
		}
Linus Torvalds's avatar
Linus Torvalds committed
1969
	}
1970
	if (!ret) {
1971
		printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
Linus Torvalds's avatar
Linus Torvalds committed
1972 1973 1974
		goto error_out;
	}

1975
	udf_debug("Lastblock=%d\n", sbi->s_last_block);
Linus Torvalds's avatar
Linus Torvalds committed
1976

1977
	if (sbi->s_lvid_bh) {
Marcin Slusarz's avatar
Marcin Slusarz committed
1978 1979
		struct logicalVolIntegrityDescImpUse *lvidiu =
							udf_sb_lvidiu(sbi);
1980 1981
		uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
		uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
Marcin Slusarz's avatar
Marcin Slusarz committed
1982 1983
		/* uint16_t maxUDFWriteRev =
				le16_to_cpu(lvidiu->maxUDFWriteRev); */
Linus Torvalds's avatar
Linus Torvalds committed
1984

1985
		if (minUDFReadRev > UDF_MAX_READ_VERSION) {
Marcin Slusarz's avatar
Marcin Slusarz committed
1986 1987
			printk(KERN_ERR "UDF-fs: minUDFReadRev=%x "
					"(max is %x)\n",
1988
			       le16_to_cpu(lvidiu->minUDFReadRev),
1989
			       UDF_MAX_READ_VERSION);
Linus Torvalds's avatar
Linus Torvalds committed
1990
			goto error_out;
Marcin Slusarz's avatar
Marcin Slusarz committed
1991
		} else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
Linus Torvalds's avatar
Linus Torvalds committed
1992 1993
			sb->s_flags |= MS_RDONLY;

1994
		sbi->s_udfrev = minUDFWriteRev;
Linus Torvalds's avatar
Linus Torvalds committed
1995 1996 1997 1998 1999 2000 2001

		if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
			UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
		if (minUDFReadRev >= UDF_VERS_USE_STREAMS)
			UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
	}

2002
	if (!sbi->s_partitions) {
2003
		printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
Linus Torvalds's avatar
Linus Torvalds committed
2004 2005 2006
		goto error_out;
	}

Marcin Slusarz's avatar
Marcin Slusarz committed
2007 2008 2009 2010
	if (sbi->s_partmaps[sbi->s_partition].s_partition_flags &
			UDF_PART_FLAG_READ_ONLY) {
		printk(KERN_NOTICE "UDF-fs: Partition marked readonly; "
				   "forcing readonly mount\n");
2011
		sb->s_flags |= MS_RDONLY;
2012
	}
2013

2014
	if (udf_find_fileset(sb, &fileset, &rootdir)) {
2015
		printk(KERN_WARNING "UDF-fs: No fileset found\n");
Linus Torvalds's avatar
Linus Torvalds committed
2016 2017 2018
		goto error_out;
	}

2019
	if (!silent) {
2020
		struct timestamp ts;
2021
		udf_time_to_disk_stamp(&ts, sbi->s_record_time);
Adrian Bunk's avatar
Adrian Bunk committed
2022
		udf_info("UDF: Mounting volume '%s', "
2023
			 "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
2024 2025
			 sbi->s_volume_ident, le16_to_cpu(ts.year), ts.month, ts.day,
			 ts.hour, ts.minute, le16_to_cpu(ts.typeAndTimezone));
Linus Torvalds's avatar
Linus Torvalds committed
2026 2027 2028 2029 2030 2031 2032
	}
	if (!(sb->s_flags & MS_RDONLY))
		udf_open_lvid(sb);

	/* Assign the root inode */
	/* assign inodes by physical block number */
	/* perhaps it's not extensible enough, but for now ... */
2033
	inode = udf_iget(sb, &rootdir);
2034
	if (!inode) {
Marcin Slusarz's avatar
Marcin Slusarz committed
2035 2036
		printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, "
				"partition=%d\n",
2037
		       rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
Linus Torvalds's avatar
Linus Torvalds committed
2038 2039 2040 2041 2042
		goto error_out;
	}

	/* Allocate a dentry for the root inode */
	sb->s_root = d_alloc_root(inode);
2043
	if (!sb->s_root) {
2044
		printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
Linus Torvalds's avatar
Linus Torvalds committed
2045 2046 2047
		iput(inode);
		goto error_out;
	}
Jan Kara's avatar
Jan Kara committed
2048
	sb->s_maxbytes = MAX_LFS_FILESIZE;
Linus Torvalds's avatar
Linus Torvalds committed
2049 2050
	return 0;

2051
error_out:
2052 2053
	if (sbi->s_vat_inode)
		iput(sbi->s_vat_inode);
2054 2055 2056
	if (sbi->s_partitions)
		for (i = 0; i < sbi->s_partitions; i++)
			udf_free_partition(&sbi->s_partmaps[i]);
Linus Torvalds's avatar
Linus Torvalds committed
2057 2058
#ifdef CONFIG_UDF_NLS
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
2059
		unload_nls(sbi->s_nls_map);
Linus Torvalds's avatar
Linus Torvalds committed
2060 2061 2062
#endif
	if (!(sb->s_flags & MS_RDONLY))
		udf_close_lvid(sb);
2063 2064 2065
	brelse(sbi->s_lvid_bh);

	kfree(sbi->s_partmaps);
Linus Torvalds's avatar
Linus Torvalds committed
2066 2067
	kfree(sbi);
	sb->s_fs_info = NULL;
2068

Linus Torvalds's avatar
Linus Torvalds committed
2069 2070 2071
	return -EINVAL;
}

Adrian Bunk's avatar
Adrian Bunk committed
2072 2073
static void udf_error(struct super_block *sb, const char *function,
		      const char *fmt, ...)
Linus Torvalds's avatar
Linus Torvalds committed
2074 2075 2076
{
	va_list args;

2077
	if (!(sb->s_flags & MS_RDONLY)) {
Linus Torvalds's avatar
Linus Torvalds committed
2078 2079 2080 2081
		/* mark sb error */
		sb->s_dirt = 1;
	}
	va_start(args, fmt);
2082
	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
Linus Torvalds's avatar
Linus Torvalds committed
2083
	va_end(args);
2084
	printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
2085
		sb->s_id, function, error_buf);
Linus Torvalds's avatar
Linus Torvalds committed
2086 2087 2088
}

void udf_warning(struct super_block *sb, const char *function,
2089
		 const char *fmt, ...)
Linus Torvalds's avatar
Linus Torvalds committed
2090 2091 2092
{
	va_list args;

2093
	va_start(args, fmt);
2094
	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
Linus Torvalds's avatar
Linus Torvalds committed
2095 2096
	va_end(args);
	printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
2097
	       sb->s_id, function, error_buf);
Linus Torvalds's avatar
Linus Torvalds committed
2098 2099
}

2100
static void udf_put_super(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
2101 2102
{
	int i;
2103
	struct udf_sb_info *sbi;
Linus Torvalds's avatar
Linus Torvalds committed
2104

2105
	sbi = UDF_SB(sb);
2106 2107 2108

	lock_kernel();

2109 2110
	if (sbi->s_vat_inode)
		iput(sbi->s_vat_inode);
2111 2112 2113
	if (sbi->s_partitions)
		for (i = 0; i < sbi->s_partitions; i++)
			udf_free_partition(&sbi->s_partmaps[i]);
Linus Torvalds's avatar
Linus Torvalds committed
2114 2115
#ifdef CONFIG_UDF_NLS
	if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
2116
		unload_nls(sbi->s_nls_map);
Linus Torvalds's avatar
Linus Torvalds committed
2117 2118 2119
#endif
	if (!(sb->s_flags & MS_RDONLY))
		udf_close_lvid(sb);
2120 2121
	brelse(sbi->s_lvid_bh);
	kfree(sbi->s_partmaps);
Linus Torvalds's avatar
Linus Torvalds committed
2122 2123
	kfree(sb->s_fs_info);
	sb->s_fs_info = NULL;
2124 2125

	unlock_kernel();
Linus Torvalds's avatar
Linus Torvalds committed
2126 2127
}

2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146
static int udf_sync_fs(struct super_block *sb, int wait)
{
	struct udf_sb_info *sbi = UDF_SB(sb);

	mutex_lock(&sbi->s_alloc_mutex);
	if (sbi->s_lvid_dirty) {
		/*
		 * Blockdevice will be synced later so we don't have to submit
		 * the buffer for IO
		 */
		mark_buffer_dirty(sbi->s_lvid_bh);
		sb->s_dirt = 0;
		sbi->s_lvid_dirty = 0;
	}
	mutex_unlock(&sbi->s_alloc_mutex);

	return 0;
}

2147
static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds's avatar
Linus Torvalds committed
2148
{
2149
	struct super_block *sb = dentry->d_sb;
2150 2151
	struct udf_sb_info *sbi = UDF_SB(sb);
	struct logicalVolIntegrityDescImpUse *lvidiu;
Coly Li's avatar
Coly Li committed
2152
	u64 id = huge_encode_dev(sb->s_bdev->bd_dev);
2153 2154 2155 2156 2157

	if (sbi->s_lvid_bh != NULL)
		lvidiu = udf_sb_lvidiu(sbi);
	else
		lvidiu = NULL;
2158

Linus Torvalds's avatar
Linus Torvalds committed
2159 2160
	buf->f_type = UDF_SUPER_MAGIC;
	buf->f_bsize = sb->s_blocksize;
2161
	buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
Linus Torvalds's avatar
Linus Torvalds committed
2162 2163
	buf->f_bfree = udf_count_free(sb);
	buf->f_bavail = buf->f_bfree;
2164 2165 2166
	buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
					  le32_to_cpu(lvidiu->numDirs)) : 0)
			+ buf->f_bfree;
Linus Torvalds's avatar
Linus Torvalds committed
2167
	buf->f_ffree = buf->f_bfree;
2168
	buf->f_namelen = UDF_NAME_LEN - 2;
Coly Li's avatar
Coly Li committed
2169 2170
	buf->f_fsid.val[0] = (u32)id;
	buf->f_fsid.val[1] = (u32)(id >> 32);
Linus Torvalds's avatar
Linus Torvalds committed
2171 2172 2173 2174

	return 0;
}

Marcin Slusarz's avatar
Marcin Slusarz committed
2175 2176
static unsigned int udf_count_free_bitmap(struct super_block *sb,
					  struct udf_bitmap *bitmap)
Linus Torvalds's avatar
Linus Torvalds committed
2177 2178 2179 2180 2181
{
	struct buffer_head *bh = NULL;
	unsigned int accum = 0;
	int index;
	int block = 0, newblock;
2182
	struct kernel_lb_addr loc;
Linus Torvalds's avatar
Linus Torvalds committed
2183 2184 2185 2186 2187 2188 2189 2190
	uint32_t bytes;
	uint8_t *ptr;
	uint16_t ident;
	struct spaceBitmapDesc *bm;

	lock_kernel();

	loc.logicalBlockNum = bitmap->s_extPosition;
2191
	loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
2192
	bh = udf_read_ptagged(sb, &loc, 0, &ident);
Linus Torvalds's avatar
Linus Torvalds committed
2193

2194
	if (!bh) {
Linus Torvalds's avatar
Linus Torvalds committed
2195 2196
		printk(KERN_ERR "udf: udf_count_free failed\n");
		goto out;
2197
	} else if (ident != TAG_IDENT_SBD) {
Jan Kara's avatar
Jan Kara committed
2198
		brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
2199 2200 2201 2202 2203 2204
		printk(KERN_ERR "udf: udf_count_free failed\n");
		goto out;
	}

	bm = (struct spaceBitmapDesc *)bh->b_data;
	bytes = le32_to_cpu(bm->numOfBytes);
2205 2206
	index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
	ptr = (uint8_t *)bh->b_data;
Linus Torvalds's avatar
Linus Torvalds committed
2207

2208
	while (bytes > 0) {
2209 2210 2211 2212
		u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index);
		accum += bitmap_weight((const unsigned long *)(ptr + index),
					cur_bytes * 8);
		bytes -= cur_bytes;
2213
		if (bytes) {
Jan Kara's avatar
Jan Kara committed
2214
			brelse(bh);
2215
			newblock = udf_get_lb_pblock(sb, &loc, ++block);
Linus Torvalds's avatar
Linus Torvalds committed
2216
			bh = udf_tread(sb, newblock);
2217
			if (!bh) {
Linus Torvalds's avatar
Linus Torvalds committed
2218 2219 2220 2221
				udf_debug("read failed\n");
				goto out;
			}
			index = 0;
2222
			ptr = (uint8_t *)bh->b_data;
Linus Torvalds's avatar
Linus Torvalds committed
2223 2224
		}
	}
Jan Kara's avatar
Jan Kara committed
2225
	brelse(bh);
Linus Torvalds's avatar
Linus Torvalds committed
2226

2227
out:
Linus Torvalds's avatar
Linus Torvalds committed
2228 2229 2230 2231 2232
	unlock_kernel();

	return accum;
}

Marcin Slusarz's avatar
Marcin Slusarz committed
2233 2234
static unsigned int udf_count_free_table(struct super_block *sb,
					 struct inode *table)
Linus Torvalds's avatar
Linus Torvalds committed
2235 2236
{
	unsigned int accum = 0;
2237
	uint32_t elen;
2238
	struct kernel_lb_addr eloc;
Linus Torvalds's avatar
Linus Torvalds committed
2239
	int8_t etype;
2240
	struct extent_position epos;
Linus Torvalds's avatar
Linus Torvalds committed
2241 2242 2243

	lock_kernel();

2244
	epos.block = UDF_I(table)->i_location;
2245 2246
	epos.offset = sizeof(struct unallocSpaceEntry);
	epos.bh = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
2247

2248
	while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
Linus Torvalds's avatar
Linus Torvalds committed
2249
		accum += (elen >> table->i_sb->s_blocksize_bits);
2250

Jan Kara's avatar
Jan Kara committed
2251
	brelse(epos.bh);
Linus Torvalds's avatar
Linus Torvalds committed
2252 2253 2254 2255 2256

	unlock_kernel();

	return accum;
}
2257 2258

static unsigned int udf_count_free(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
2259 2260
{
	unsigned int accum = 0;
2261 2262
	struct udf_sb_info *sbi;
	struct udf_part_map *map;
Linus Torvalds's avatar
Linus Torvalds committed
2263

2264 2265
	sbi = UDF_SB(sb);
	if (sbi->s_lvid_bh) {
Marcin Slusarz's avatar
Marcin Slusarz committed
2266 2267 2268
		struct logicalVolIntegrityDesc *lvid =
			(struct logicalVolIntegrityDesc *)
			sbi->s_lvid_bh->b_data;
2269
		if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) {
Marcin Slusarz's avatar
Marcin Slusarz committed
2270 2271
			accum = le32_to_cpu(
					lvid->freeSpaceTable[sbi->s_partition]);
Linus Torvalds's avatar
Linus Torvalds committed
2272 2273 2274 2275 2276 2277 2278 2279
			if (accum == 0xFFFFFFFF)
				accum = 0;
		}
	}

	if (accum)
		return accum;

2280 2281
	map = &sbi->s_partmaps[sbi->s_partition];
	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
2282
		accum += udf_count_free_bitmap(sb,
2283
					       map->s_uspace.s_bitmap);
Linus Torvalds's avatar
Linus Torvalds committed
2284
	}
2285
	if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
2286
		accum += udf_count_free_bitmap(sb,
2287
					       map->s_fspace.s_bitmap);
Linus Torvalds's avatar
Linus Torvalds committed
2288 2289 2290 2291
	}
	if (accum)
		return accum;

2292
	if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
2293
		accum += udf_count_free_table(sb,
2294
					      map->s_uspace.s_table);
Linus Torvalds's avatar
Linus Torvalds committed
2295
	}
2296
	if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
2297
		accum += udf_count_free_table(sb,
2298
					      map->s_fspace.s_table);
Linus Torvalds's avatar
Linus Torvalds committed
2299 2300 2301 2302
	}

	return accum;
}