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