uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);	uopt.uid = -1;	uopt.gid = -1;	uopt.umask = 0;	memset(UDF_SB(sb), 0x00, sizeof(struct udf_sb_info));#if UDFFS_RW != 1	sb->s_flags |= MS_RDONLY;#endif	if (!udf_parse_options((char *)options, &uopt))		goto error_out;	if (uopt.flags & (1 << UDF_FLAG_UTF8) &&	    uopt.flags & (1 << UDF_FLAG_NLS_MAP))	{		udf_error(sb, "udf_read_super",			"utf8 cannot be combined with iocharset\n");		goto error_out;	}#ifdef CONFIG_NLS	if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map)	{		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;	UDF_SB(sb)->s_flags = uopt.flags;	UDF_SB(sb)->s_uid = uopt.uid;	UDF_SB(sb)->s_gid = uopt.gid;	UDF_SB(sb)->s_umask = uopt.umask;	UDF_SB(sb)->s_nls_map = uopt.nls_map;	/* Set the block size for all transfers */	if (!udf_set_blocksize(sb, uopt.blocksize))		goto error_out;	if ( uopt.session == 0xFFFFFFFF )		UDF_SB_SESSION(sb) = udf_get_last_session(sb);	else		UDF_SB_SESSION(sb) = uopt.session;	udf_debug("Multi-session=%d\n", UDF_SB_SESSION(sb));	UDF_SB_LASTBLOCK(sb) = uopt.lastblock;	UDF_SB_ANCHOR(sb)[0] = UDF_SB_ANCHOR(sb)[1] = 0;	UDF_SB_ANCHOR(sb)[2] = uopt.anchor;	UDF_SB_ANCHOR(sb)[3] = UDF_SB_SESSION(sb) + 256;	if (udf_check_valid(sb, uopt.novrs, silent)) /* read volume recognition sequences */	{		printk("UDF-fs: No VRS found\n"); 		goto error_out;	}	udf_find_anchor(sb);	/* Fill in the rest of the superblock */	sb->s_op = &udf_sb_ops;	sb->dq_op = NULL;	sb->s_dirt = 0;	sb->s_magic = UDF_SUPER_MAGIC;	if (udf_load_partition(sb, &fileset))	{		printk("UDF-fs: No partition found (1)\n");		goto error_out;	}	udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb));	if ( UDF_SB_LVIDBH(sb) )	{		Uint16 minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);		Uint16 minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);		/* Uint16 maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */		if (minUDFReadRev > UDF_MAX_READ_VERSION)		{			printk("UDF-fs: minUDFReadRev=%x (max is %x)\n",				UDF_SB_LVIDIU(sb)->minUDFReadRev, UDF_MAX_READ_VERSION);			goto error_out;		}		else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)		{			sb->s_flags |= MS_RDONLY;		}		UDF_SB_UDFREV(sb) = minUDFWriteRev;		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);	}	if ( !UDF_SB_NUMPARTS(sb) )	{		printk("UDF-fs: No partition found (2)\n");		goto error_out;	}	if ( udf_find_fileset(sb, &fileset, &rootdir) )	{		printk("UDF-fs: No fileset found\n");		goto error_out;	}	if (!silent)	{		timestamp ts;		udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb), 0);		udf_info("UDF %s-%s (%s) Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n",			UDFFS_VERSION, UDFFS_RW ? "rw" : "ro", UDFFS_DATE,			UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,			ts.typeAndTimezone);	}	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 ... */	inode = udf_iget(sb, rootdir); 	if (!inode)	{		printk("UDF-fs: Error in udf_iget, block=%d, partition=%d\n",			rootdir.logicalBlockNum, rootdir.partitionReferenceNum);		goto error_out;	}	/* Allocate a dentry for the root inode */	sb->s_root = d_alloc_root(inode);	if (!sb->s_root)	{		printk("UDF-fs: Couldn't allocate root dentry\n");		iput(inode);		goto error_out;	}	sb->s_maxbytes = ~0ULL;	return sb;error_out:	if (UDF_SB_VAT(sb))		iput(UDF_SB_VAT(sb));	if (UDF_SB_NUMPARTS(sb))	{		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)			iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)			iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)		{			for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_uspace); i++)			{				if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i))					udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i));			}			kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);		}		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)		{			for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_fspace); i++)			{				if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i))					udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i));			}			kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);		}		if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)		{			for (i=0; i<4; i++)				udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);		}	}#ifdef CONFIG_NLS	if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))		unload_nls(UDF_SB(sb)->s_nls_map);#endif	if (!(sb->s_flags & MS_RDONLY))		udf_close_lvid(sb);	udf_release_data(UDF_SB_LVIDBH(sb));	UDF_SB_FREE(sb);	return NULL;}void udf_error(struct super_block *sb, const char *function,	const char *fmt, ...){	va_list args;	if (!(sb->s_flags & MS_RDONLY))	{		/* mark sb error */		sb->s_dirt = 1;	}	va_start(args, fmt);	vsprintf(error_buf, fmt, args);	va_end(args);	printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",		bdevname(sb->s_dev), function, error_buf);}void udf_warning(struct super_block *sb, const char *function,	const char *fmt, ...){	va_list args;	va_start (args, fmt);	vsprintf(error_buf, fmt, args);	va_end(args);	printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",		bdevname(sb->s_dev), function, error_buf);}/* * udf_put_super * * PURPOSE *	Prepare for destruction of the superblock. * * DESCRIPTION *	Called before the filesystem is unmounted. * * HISTORY *	July 1, 1997 - Andrew E. Mileski *	Written, tested, and released. */static voidudf_put_super(struct super_block *sb){	int i;	if (UDF_SB_VAT(sb))		iput(UDF_SB_VAT(sb));	if (UDF_SB_NUMPARTS(sb))	{		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)			iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)			iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)		{			for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_uspace); i++)			{				if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i))					udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i));			}			kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);		}		if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)		{			for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_fspace); i++)			{				if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i))					udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i));			}			kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);		}		if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)		{			for (i=0; i<4; i++)				udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);		}	}#ifdef CONFIG_NLS	if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))		unload_nls(UDF_SB(sb)->s_nls_map);#endif	if (!(sb->s_flags & MS_RDONLY))		udf_close_lvid(sb);	udf_release_data(UDF_SB_LVIDBH(sb));	UDF_SB_FREE(sb);}/* * udf_stat_fs * * PURPOSE *	Return info about the filesystem. * * DESCRIPTION *	Called by sys_statfs() * * HISTORY *	July 1, 1997 - Andrew E. Mileski *	Written, tested, and released. */static intudf_statfs(struct super_block *sb, struct statfs *buf){	buf->f_type = UDF_SUPER_MAGIC;	buf->f_bsize = sb->s_blocksize;	buf->f_blocks = UDF_SB_PARTLEN(sb, UDF_SB_PARTITION(sb));	buf->f_bfree = udf_count_free(sb);	buf->f_bavail = buf->f_bfree;	buf->f_files = (UDF_SB_LVIDBH(sb) ?		(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +		le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree;	buf->f_ffree = buf->f_bfree;	/* __kernel_fsid_t f_fsid */	buf->f_namelen = UDF_NAME_LEN;	return 0;}static unsigned char udf_bitmap_lookup[16] = {	0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};static unsigned intudf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap){	struct buffer_head *bh = NULL;	unsigned int accum = 0;	int index;	int block = 0, newblock;	lb_addr loc;	Uint32 bytes;	Uint8 value;	Uint8 *ptr;	Uint16 ident;	struct SpaceBitmapDesc *bm;	loc.logicalBlockNum = bitmap->s_extPosition;	loc.partitionReferenceNum = UDF_SB_PARTITION(sb);	bh = udf_read_ptagged(sb, loc, 0, &ident);	if (!bh)	{		printk(KERN_ERR "udf: udf_count_free failed\n");		return 0;	}	else if (ident != TID_SPACE_BITMAP_DESC)	{		udf_release_data(bh);		printk(KERN_ERR "udf: udf_count_free failed\n");		return 0;	}	bm = (struct SpaceBitmapDesc *)bh->b_data;	bytes = bm->numOfBytes;	index = sizeof(struct SpaceBitmapDesc); /* offset in first block only */	ptr = (Uint8 *)bh->b_data;	while ( bytes > 0 )	{		while ((bytes > 0) && (index < sb->s_blocksize))		{			value = ptr[index];			accum += udf_bitmap_lookup[ value & 0x0f ];			accum += udf_bitmap_lookup[ value >> 4 ];			index++;			bytes--;		}		if ( bytes )		{			udf_release_data(bh);			newblock = udf_get_lb_pblock(sb, loc, ++block);			bh = udf_tread(sb, newblock);			if (!bh)			{				udf_debug("read failed\n");				return accum;			}			index = 0;			ptr = (Uint8 *)bh->b_data;		}	}	udf_release_data(bh);	return accum;}static unsigned intudf_count_free_table(struct super_block *sb, struct inode * table){	unsigned int accum = 0;	Uint32 extoffset, elen;	lb_addr bloc, eloc;	Sint8 etype;	struct buffer_head *bh = NULL;	bloc = UDF_I_LOCATION(table);	extoffset = sizeof(struct UnallocatedSpaceEntry);	while ((etype = udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)	{		accum += (elen >> table->i_sb->s_blocksize_bits);	}	udf_release_data(bh);	return accum;}	static unsigned intudf_count_free(struct super_block *sb){	unsigned int accum = 0;	if (UDF_SB_LVIDBH(sb))	{		if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > UDF_SB_PARTITION(sb))		{			accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]);			if (accum == 0xFFFFFFFF)				accum = 0;		}	}	if (accum)		return accum;	if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)	{		accum += udf_count_free_bitmap(sb,			UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);	}	if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)	{		accum += udf_count_free_bitmap(sb,			UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);	}	if (accum)		return accum;	if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)	{		accum += udf_count_free_table(sb,			UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);	}	if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)	{		accum += udf_count_free_table(sb,			UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);	}	return accum;}