Attachment #2145 for bug #12565

View | Details | Raw Unified | Return to bug 12565
Collapse All | Expand All




{
	struct udf_sb_info *sbi = UDF_SB(sb);
	uint32_t start, end;
	uint32_t elen;
	kernel_lb_addr eloc;
	struct extent_position oepos, epos;
	int8_t etype;
	int i;


	start = bloc.logicalBlockNum + offset;
	end = bloc.logicalBlockNum + offset + count - 1;

	epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
	elen = 0;
	epos.block = oepos.block = UDF_I_LOCATION(table);
	epos.bh = oepos.bh = NULL;
	obh = nbh = NULL;

	while (count && (etype =
		udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
	{
		if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==
			start))

				start += count;
				count = 0;
			}
			udf_write_aext(table, &oepos, eloc, elen, 1);
		}
		else if (eloc.logicalBlockNum == (end + 1))
		{

				end -= count;
				count = 0;
			}
			udf_write_aext(table, &oepos, eloc, elen, 1);
		}

		if (epos.bh != oepos.bh)
		{
			i = -1;
			oepos.block = epos.block;
			brelse(oepos.bh);
			get_bh(epos.bh);
			oepos.bh = epos.bh;
			oepos.offset = 0;
		}
		else
			oepos.offset = epos.offset;
	}

	if (count)

			adsize = sizeof(long_ad);
		else
		{
			brelse(oepos.bh);
			brelse(epos.bh);
			goto error_return;
		}

		if (epos.offset + (2 * adsize) > sb->s_blocksize)
		{
			char *sptr, *dptr;
			int loffset;
	
			brelse(oepos.bh);
			oepos = epos;
			obloc = nbloc;
			oextoffset = nextoffset;

			/* Steal a block from the extent being free'd */
			epos.block.logicalBlockNum = eloc.logicalBlockNum;
			eloc.logicalBlockNum ++;
			elen -= sb->s_blocksize;

			if (!(epos.bh = udf_tread(sb,
				udf_get_lb_pblock(sb, epos.block, 0))))
			{
				brelse(oepos.bh);
				goto error_return;
			}
			aed = (struct allocExtDesc *)(epos.bh->b_data);
			aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);
			if (epos.offset + adsize > sb->s_blocksize)
			{
				loffset = epos.offset;
				aed->lengthAllocDescs = cpu_to_le32(adsize);
				sptr = UDF_I_DATA(inode) + epos.offset -
					udf_file_entry_alloc_offset(inode) +
					UDF_I_LENEATTR(inode) - adsize;
				dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
				memcpy(dptr, sptr, adsize);
				epos.offset = sizeof(struct allocExtDesc) + adsize;
			}
			else
			{
				loffset = epos.offset + adsize;
				aed->lengthAllocDescs = cpu_to_le32(0);
				sptr = oepos.bh->b_data + epos.offset;
				epos.offset = sizeof(struct allocExtDesc);

				if (oepos.bh)
				{
					aed = (struct allocExtDesc *)oepos.bh->b_data;
					aed->lengthAllocDescs =
						cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
				}

				}
			}
			if (UDF_SB_UDFREV(sb) >= 0x0200)
				udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
					epos.block.logicalBlockNum, sizeof(tag));
			else
				udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,
					epos.block.logicalBlockNum, sizeof(tag));
			switch (UDF_I_ALLOCTYPE(table))
			{
				case ICBTAG_FLAG_AD_SHORT:

					sad->extLength = cpu_to_le32(
						EXT_NEXT_EXTENT_ALLOCDECS |
						sb->s_blocksize);
					sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);
					break;
				}
				case ICBTAG_FLAG_AD_LONG:

					lad->extLength = cpu_to_le32(
						EXT_NEXT_EXTENT_ALLOCDECS |
						sb->s_blocksize);
					lad->extLocation = cpu_to_lelb(epos.block);
					break;
				}
			}
			if (oepos.bh)
			{
				udf_update_tag(oepos.bh->b_data, loffset);
				mark_buffer_dirty(oepos.bh);
			}
			else
				mark_inode_dirty(table);


		if (elen) /* It's possible that stealing the block emptied the extent */
		{
			udf_write_aext(table, &epos, eloc, elen, 1);

			if (!epos.bh)
			{
				UDF_I_LENALLOC(table) += adsize;
				mark_inode_dirty(table);
			}
			else
			{
				aed = (struct allocExtDesc *)epos.bh->b_data;
				aed->lengthAllocDescs =
					cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
				udf_update_tag(epos.bh->b_data, epos.offset);
				mark_buffer_dirty(epos.bh);
			}
		}
	}

	brelse(epos.bh);
	brelse(oepos.bh);

error_return:
	sb->s_dirt = 1;

{
	struct udf_sb_info *sbi = UDF_SB(sb);
	int alloc_count = 0;
	uint32_t elen, adsize;
	kernel_lb_addr eloc;
	struct extent_position epos;
	int8_t etype = -1;

	if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))

		return 0;

	mutex_lock(&sbi->s_alloc_mutex);
	epos.offset = sizeof(struct unallocSpaceEntry);
	epos.block = UDF_I_LOCATION(table);
	epos.bh = NULL;
	bh = NULL;
	eloc.logicalBlockNum = 0xFFFFFFFF;

	while (first_block != eloc.logicalBlockNum && (etype =
		udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
	{
		udf_debug("eloc=%d, elen=%d, first_block=%d\n",
			eloc.logicalBlockNum, elen, first_block);


	if (first_block == eloc.logicalBlockNum)
	{
		epos.offset -= adsize;

		alloc_count = (elen >> sb->s_blocksize_bits);
		if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count))

			alloc_count = block_count;
			eloc.logicalBlockNum += alloc_count;
			elen -= (alloc_count << sb->s_blocksize_bits);
			udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1);
		}
		else
			udf_delete_aext(table, epos, eloc, (etype << 30) | elen);
	}
	else
		alloc_count = 0;

	brelse(epos.bh);

	if (alloc_count && UDF_SB_LVIDBH(sb))
	{

	struct udf_sb_info *sbi = UDF_SB(sb);
	uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
	uint32_t newblock = 0, adsize;
	uint32_t elen, goal_elen = 0;
	kernel_lb_addr eloc, goal_eloc;
	struct extent_position epos, goal_epos;
	int8_t etype;

	*err = -ENOSPC;

	   We store the buffer_head, bloc, and extoffset of the current closest
	   match and use that when we are done.
	*/
	epos.offset = sizeof(struct unallocSpaceEntry);
	epos.block = UDF_I_LOCATION(table);
	epos.bh = goal_epos.bh = NULL;

	goal_bh = bh = NULL;

	while (spread && (etype =
		udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
	{
		if (goal >= eloc.logicalBlockNum)
		{

		if (nspread < spread)
		{
			spread = nspread;
			if (goal_epos.bh != epos.bh)
			{
				brelse(goal_epos.bh);
				goal_epos.bh = epos.bh;
				get_bh(goal_epos.bh);
			}
			goal_epos.block = epos.block;
			goal_epos.offset = epos.offset - adsize;
			goal_eloc = eloc;
			goal_elen = (etype << 30) | elen;
		}
	}

	brelse(epos.bh);

	if (spread == 0xFFFFFFFF)
	{
		brelse(goal_epos.bh);
		mutex_unlock(&sbi->s_alloc_mutex);
		return 0;
	}


	if (inode && DQUOT_ALLOC_BLOCK(inode, 1))
	{
		brelse(goal_epos.bh);
		mutex_unlock(&sbi->s_alloc_mutex);
		*err = -EDQUOT;
		return 0;
	}

	if (goal_elen)
		udf_write_aext(table, &goal_epos, goal_eloc, goal_elen, 1);
	else
		udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
	brelse(goal_epos.bh);

	if (UDF_SB_LVIDBH(sb))
	{

	struct inode * inode,
	uint16_t partition, uint32_t goal, int *err)
{
	int ret;

	if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP)
	{
		ret = udf_bitmap_new_block(sb, inode,
			UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
			partition, goal, err);
		return ret;
	}
	else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE)
	{




	uint16_t liu;
	uint8_t lfi;
	loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
	struct buffer_head *tmp, *bha[16];
	kernel_lb_addr eloc;
	uint32_t elen;
	sector_t offset;
	int i, num;
	unsigned int dt_type;
	struct extent_position epos = { NULL, 0, {0, 0}};

	if (nf_pos >= size)
		return 0;

	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
		fibh.sbh = fibh.ebh = NULL;
	else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
		&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
	{
		offset >>= dir->i_sb->s_blocksize_bits;
		block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
		if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
		{
			if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
				epos.offset -= sizeof(short_ad);
			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
				epos.offset -= sizeof(long_ad);
		}
		else
			offset = 0;

		if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))
		{
			brelse(epos.bh);
			return -EIO;
		}
	

	}
	else
	{
		brelse(epos.bh);
		return -ENOENT;
	}


	{
		filp->f_pos = nf_pos + 1;

		fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);

		if (!fi)
		{
			if (fibh.sbh != fibh.ebh)
				brelse(fibh.ebh);
			brelse(fibh.sbh);
			brelse(epos.bh);
			return 0;
		}


			if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0)
			{
				if (fibh.sbh != fibh.ebh)
					brelse(fibh.ebh);
				brelse(fibh.sbh);
				brelse(epos.bh);
	 			return 0;
			}
		}

	filp->f_pos = nf_pos + 1;

	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
	brelse(epos.bh);

	return 0;
}





	if (!ad)
	{
		brelse(*bh);
		*error = 1;
		return NULL;
	}

	if (*offset == dir->i_sb->s_blocksize)
	{
		brelse(*bh);
		block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
		if (!block)
			return NULL;

		remainder = dir->i_sb->s_blocksize - loffset;
		memcpy((uint8_t *)ad, (*bh)->b_data + loffset, remainder);

		brelse(*bh);
		block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
		if (!block)
			return NULL;

udf_fileident_read(struct inode *dir, loff_t *nf_pos,
	struct udf_fileident_bh *fibh,
	struct fileIdentDesc *cfi,
	struct extent_position *epos,
	kernel_lb_addr *eloc, uint32_t *elen,
	sector_t *offset)
{
	struct fileIdentDesc *fi;
	int i, num, block;


	if (fibh->eoffset == dir->i_sb->s_blocksize)
	{
		int lextoffset = epos->offset;

		if (udf_next_aext(dir, epos, eloc, elen, 1) !=
			(EXT_RECORDED_ALLOCATED >> 30))
		{
			return NULL;
		}

		block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);


		if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
			*offset = 0;
		else
			epos->offset = lextoffset;

		brelse(fibh->sbh);
		if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
			return NULL;
		fibh->soffset = fibh->eoffset = 0;

	}
	else if (fibh->sbh != fibh->ebh)
	{
		brelse(fibh->sbh);
		fibh->sbh = fibh->ebh;
	}


	}
	else if (fibh->eoffset > dir->i_sb->s_blocksize)
	{
		int lextoffset = epos->offset;

		if (udf_next_aext(dir, epos, eloc, elen, 1) !=
			(EXT_RECORDED_ALLOCATED >> 30))
		{
			return NULL;
		}

		block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);


		if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
			*offset = 0;
		else
			epos->offset = lextoffset;

		fibh->soffset -= dir->i_sb->s_blocksize;
		fibh->eoffset -= dir->i_sb->s_blocksize;




#include <linux/smp_lock.h>
#include <linux/pagemap.h>
#include <linux/buffer_head.h>
#include <linux/aio.h>

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

	.commit_write		= udf_adinicb_commit_write,
};

static ssize_t udf_file_aio_write(struct kiocb *iocb, const char __user *buf,
			      size_t count, loff_t ppos)
{
	ssize_t retval;
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_dentry->d_inode;
	int err, pos;


		if (file->f_flags & O_APPEND)
			pos = inode->i_size;
		else
			pos = ppos;

		if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
			pos + count))

		}
	}

	retval = generic_file_aio_write(iocb, buf, count, ppos);

	if (retval > 0)
		mark_inode_dirty(inode);

}

const struct file_operations udf_file_operations = {
	.read			= do_sync_read,
	.aio_read		= generic_file_aio_read,
	.ioctl			= udf_ioctl,
	.open			= generic_file_open,
	.mmap			= generic_file_mmap,
	.write			= do_sync_write,
	.aio_write		= udf_file_aio_write,
	.release		= udf_release_file,
	.fsync			= udf_fsync_file,
	.sendfile		= generic_file_sendfile,
};

const struct inode_operations udf_file_inode_operations = {
	.truncate		= udf_truncate,
};

Lines 21-27 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/fsync.c (-1 lines)
21	#include "udfdecl.h"	21	#include "udfdecl.h"
22		22
23	#include <linux/fs.h>	23	#include <linux/fs.h>
24	#include <linux/smp_lock.h>
25		24
26	static int udf_fsync_inode(struct inode *, int);	25	static int udf_fsync_inode(struct inode *, int);
27		26




	UDF_I_LOCATION(inode).logicalBlockNum = block;
	UDF_I_LOCATION(inode).partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
	inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
	inode->i_blksize = PAGE_SIZE;
	inode->i_blocks = 0;
	UDF_I_LENEATTR(inode) = 0;
	UDF_I_LENALLOC(inode) = 0;

	{
		UDF_I_EFE(inode) = 1;
		UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
		UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
		memset(UDF_I_DATA(inode), 0x00, inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
	}
	else
	{
		UDF_I_EFE(inode) = 0;
		UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
		memset(UDF_I_DATA(inode), 0x00, inode->i_sb->s_blocksize - sizeof(struct fileEntry));
	}
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))
		UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;




static mode_t udf_convert_permissions(struct fileEntry *);
static int udf_update_inode(struct inode *, int);
static void udf_fill_inode(struct inode *, struct buffer_head *);
static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
	long *, int *);
static int8_t udf_insert_aext(struct inode *, struct extent_position,
	kernel_lb_addr, uint32_t);
static void udf_split_extents(struct inode *, int *, int, int,
	kernel_long_ad [EXTENT_MERGE_SIZE], int *);
static void udf_prealloc_extents(struct inode *, int, int,

	 kernel_long_ad [EXTENT_MERGE_SIZE], int *);
static void udf_update_extents(struct inode *,
	kernel_long_ad [EXTENT_MERGE_SIZE], int, int,
	struct extent_position *);
static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);

/*

	clear_inode(inode);
}

/*
 * If we are going to release inode from memory, we discard preallocation and
 * truncate last inode extent to proper length. We could use drop_inode() but
 * it's called under inode_lock and thus we cannot mark inode dirty there.  We
 * use clear_inode() but we have to make sure to write inode as it's not written
 * automatically.
 */
void udf_clear_inode(struct inode *inode)
{
	if (!(inode->i_sb->s_flags & MS_RDONLY)) {
		lock_kernel();
		/* Discard preallocation for directories, symlinks, etc. */
		udf_discard_prealloc(inode);
		udf_truncate_tail_extent(inode);
		unlock_kernel();
		write_inode_now(inode, 1);
	}

	kfree(UDF_I_DATA(inode));
	UDF_I_DATA(inode) = NULL;
}

struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int *err)
{
	int newblock;
	struct buffer_head *dbh = NULL;
	kernel_lb_addr eloc;
	uint32_t elen;
	uint8_t alloctype;
	struct extent_position epos;

	struct udf_fileident_bh sfibh, dfibh;
	loff_t f_pos = udf_ext0_offset(inode) >> 2;

	mark_buffer_dirty_inode(dbh, inode);

	sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
	sfibh.sbh = sfibh.ebh = NULL;
	dfibh.soffset = dfibh.eoffset = 0;
	dfibh.sbh = dfibh.ebh = dbh;
	while ( (f_pos < size) )
	{
		UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
		sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL);
		if (!sfi)
		{
			brelse(dbh);
			return NULL;
		}
		UDF_I_ALLOCTYPE(inode) = alloctype;

			sfi->fileIdent + le16_to_cpu(sfi->lengthOfImpUse)))
		{
			UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
			brelse(dbh);
			return NULL;
		}
	}


	memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, UDF_I_LENALLOC(inode));
	UDF_I_LENALLOC(inode) = 0;
	bloc = UDF_I_LOCATION(inode);
	eloc.logicalBlockNum = *block;
	eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
	elen = inode->i_size;
	UDF_I_LENEXTENTS(inode) = elen;
	epos.bh = NULL;
	epos.block = UDF_I_LOCATION(inode);
	epos.offset = udf_file_entry_alloc_offset(inode);
	udf_add_aext(inode, &epos, eloc, elen, 0);
	/* UniqueID stuff */

	brelse(epos.bh);
	mark_inode_dirty(inode);
	return dbh;
}

	return NULL;
}

/* Extend the file by 'blocks' blocks, return the number of extents added */
int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
	kernel_long_ad *last_ext, sector_t blocks)
{
	sector_t add;
	int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
	struct super_block *sb = inode->i_sb;
	kernel_lb_addr prealloc_loc = {0, 0};
	int prealloc_len = 0;

	/* The previous extent is fake and we should not extend by anything
	 * - there's nothing to do... */
	if (!blocks && fake)
		return 0;
	/* Round the last extent up to a multiple of block size */
	if (last_ext->extLength & (sb->s_blocksize - 1)) {
		last_ext->extLength =
			(last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
			(((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
				sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
		UDF_I_LENEXTENTS(inode) =
			(UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) &
				~(sb->s_blocksize - 1);
	}
	/* Last extent are just preallocated blocks? */
	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_ALLOCATED) {
		/* Save the extent so that we can reattach it to the end */
		prealloc_loc = last_ext->extLocation;
		prealloc_len = last_ext->extLength;
		/* Mark the extent as a hole */
		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
			(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
		last_ext->extLocation.logicalBlockNum = 0;
       		last_ext->extLocation.partitionReferenceNum = 0;
	}
	/* Can we merge with the previous extent? */
	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_NOT_ALLOCATED) {
		add = ((1<<30) - sb->s_blocksize - (last_ext->extLength &
			UDF_EXTENT_LENGTH_MASK)) >> sb->s_blocksize_bits;
		if (add > blocks)
			add = blocks;
		blocks -= add;
		last_ext->extLength += add << sb->s_blocksize_bits;
	}

	if (fake) {
		udf_add_aext(inode, last_pos, last_ext->extLocation,
			last_ext->extLength, 1);
		count++;
	}
	else
		udf_write_aext(inode, last_pos, last_ext->extLocation, last_ext->extLength, 1);
	/* Managed to do everything necessary? */
	if (!blocks)
		goto out;

	/* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
	last_ext->extLocation.logicalBlockNum = 0;
       	last_ext->extLocation.partitionReferenceNum = 0;
	add = (1 << (30-sb->s_blocksize_bits)) - 1;
	last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits);
	/* Create enough extents to cover the whole hole */
	while (blocks > add) {
		blocks -= add;
		if (udf_add_aext(inode, last_pos, last_ext->extLocation,
			last_ext->extLength, 1) == -1)
			return -1;
		count++;
	}
	if (blocks) {
		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
			(blocks << sb->s_blocksize_bits);
		if (udf_add_aext(inode, last_pos, last_ext->extLocation,
			last_ext->extLength, 1) == -1)
			return -1;
		count++;
	}
out:
	/* Do we have some preallocated blocks saved? */
	if (prealloc_len) {
		if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1) == -1)
			return -1;
		last_ext->extLocation = prealloc_loc;
		last_ext->extLength = prealloc_len;
		count++;
	}
	/* last_pos should point to the last written extent... */
	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
		last_pos->offset -= sizeof(short_ad);
	else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
		last_pos->offset -= sizeof(long_ad);
	else
		return -1;
	return count;
}

static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
	int *err, long *phys, int *new)
{
	static sector_t last_block;
	struct buffer_head *result = NULL;
	kernel_long_ad laarr[EXTENT_MERGE_SIZE];
	struct extent_position prev_epos, cur_epos, next_epos;
	int count = 0, startnum = 0, endnum = 0;
	uint32_t elen = 0, tmpelen;
	kernel_lb_addr eloc, tmpeloc;
	int c = 1;
	loff_t lbcount = 0, b_off = 0;
	uint32_t newblocknum, newblock;
	sector_t offset = 0;
	int8_t etype;
	int goal = 0, pgoal = UDF_I_LOCATION(inode).logicalBlockNum;
	int lastblock = 0;

	prev_epos.offset = udf_file_entry_alloc_offset(inode);
	prev_epos.block = UDF_I_LOCATION(inode);
	prev_epos.bh = NULL;
	cur_epos = next_epos = prev_epos;
	b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;

	/* find the extent which contains the block we are looking for.
       alternate between laarr[0] and laarr[1] for locations of the
       current extent, and the previous extent */
	do
	{
		if (prev_epos.bh != cur_epos.bh)
		{
			brelse(prev_epos.bh);
			get_bh(cur_epos.bh);
			prev_epos.bh = cur_epos.bh;
		}
		if (cur_epos.bh != next_epos.bh)
		{
			brelse(cur_epos.bh);
			get_bh(next_epos.bh);
			cur_epos.bh = next_epos.bh;
		}

		lbcount += elen;

		prev_epos.block = cur_epos.block;
		cur_epos.block = next_epos.block;

		prev_epos.offset = cur_epos.offset;
		cur_epos.offset = next_epos.offset;

		if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
			break;

		c = !c;


	b_off -= lbcount;
	offset = b_off >> inode->i_sb->s_blocksize_bits;
	/*
	 * Move prev_epos and cur_epos into indirect extent if we are at
	 * the pointer to it
	 */
	udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
	udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);

	/* if the extent is allocated and recorded, return the block
       if the extent is not a multiple of the blocksize, round up */

			elen = EXT_RECORDED_ALLOCATED |
				((elen + inode->i_sb->s_blocksize - 1) &
				~(inode->i_sb->s_blocksize - 1));
			etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);
		}
		brelse(prev_epos.bh);
		brelse(cur_epos.bh);
		brelse(next_epos.bh);
		newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);
		*phys = newblock;
		return NULL;
	}

	last_block = block;
	/* Are we beyond EOF? */
	if (etype == -1)
	{
		int ret;

		if (count) {
			if (c)
				laarr[0] = laarr[1];
			startnum = 1;
		}
		else {
			/* Create a fake extent when there's not one */
			memset(&laarr[0].extLocation, 0x00, sizeof(kernel_lb_addr));
			laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
			/* Will udf_extend_file() create real extent from a fake one? */
			startnum = (offset > 0);
		}
		/* Create extents for the hole between EOF and offset */
		ret = udf_extend_file(inode, &prev_epos, laarr, offset);
		if (ret == -1) {
			brelse(prev_epos.bh);
			brelse(cur_epos.bh);
			brelse(next_epos.bh);
			/* We don't really know the error here so we just make
			 * something up */
			*err = -ENOSPC;
			return NULL;
		}
		c = 0;
		offset = 0;
		count += ret;
		/* We are not covered by a preallocated extent? */
		if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != EXT_NOT_RECORDED_ALLOCATED) {
			/* Is there any real extent? - otherwise we overwrite
			 * the fake one... */
			if (count)
				c = !c;
			laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
				inode->i_sb->s_blocksize;
			memset(&laarr[c].extLocation, 0x00, sizeof(kernel_lb_addr));
			count ++;
			endnum ++;
		}
		endnum = c+1;
		lastblock = 1;
	}
	else {
		endnum = startnum = ((count > 2) ? 2 : count);

		/* if the current extent is in position 0, swap it with the previous */
		if (!c && count != 1)
		{
			laarr[2] = laarr[0];
			laarr[0] = laarr[1];
			laarr[1] = laarr[2];
			c = 1;
		}

		/* if the current block is located in an extent, read the next extent */
		if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1)
	{
		if ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 0)) != -1)
		{
			laarr[c+1].extLength = (etype << 30) | elen;
			laarr[c+1].extLocation = eloc;

			startnum ++;
			endnum ++;
		}
		else {
			lastblock = 1;
		}
	}
	udf_release_data(cbh);
	udf_release_data(nbh);

	/* if the current extent is not recorded but allocated, get the
		block in the extent corresponding to the requested block */

		if (!(newblocknum = udf_new_block(inode->i_sb, inode,
			UDF_I_LOCATION(inode).partitionReferenceNum, goal, err)))
		{
			brelse(prev_epos.bh);
			*err = -ENOSPC;
			return NULL;
		}

	udf_merge_extents(inode, laarr, &endnum);

	/* write back the new extents, inserting new extents if the new number
	of extents is greater than the old number, and deleting extents if
	the new number of extents is less than the old number */
	udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);

	brelse(prev_epos.bh);

	if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
		UDF_I_LOCATION(inode).partitionReferenceNum, 0)))


static void udf_update_extents(struct inode *inode,
	kernel_long_ad laarr[EXTENT_MERGE_SIZE], int startnum, int endnum,
	struct extent_position *epos)
{
	int start = 0, i;
	kernel_lb_addr tmploc;

	if (startnum > endnum)
	{
		for (i=0; i<(startnum-endnum); i++)
			udf_delete_aext(inode, *epos, laarr[i].extLocation,
				laarr[i].extLength);
				laarr[i].extLength, *pbh);
		}
	}
	else if (startnum < endnum)
	{
		for (i=0; i<(endnum-startnum); i++)
		{
			udf_insert_aext(inode, *epos, laarr[i].extLocation,
				laarr[i].extLength);
			udf_next_aext(inode, epos, &laarr[i].extLocation,
				&laarr[i].extLength, 1);
			start ++;
		}
	}

	for (i=start; i<endnum; i++)
	{
		udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
		udf_write_aext(inode, epos, laarr[i].extLocation,
			laarr[i].extLength, 1);
	}
}


	 *      i_nlink = 1
	 *      i_op = NULL;
	 */
	inode->i_blksize = PAGE_SIZE;

	bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);

	if (!bh)

	{
		printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
			inode->i_ino, ident);
		brelse(bh);
		make_bad_inode(inode);
		return;
	}

						ident == TAG_IDENT_EFE)
					{
						memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(kernel_lb_addr));
						brelse(bh);
						brelse(ibh);
						brelse(nbh);
						__udf_read_inode(inode);
						return;
					}
					else
					{
						brelse(nbh);
						brelse(ibh);
					}
				}
				else
					brelse(ibh);
			}
		}
		else
			brelse(ibh);
	}
	else if (le16_to_cpu(fe->icbTag.strategyType) != 4)
	{
		printk(KERN_ERR "udf: unsupported strategy type: %d\n",
			le16_to_cpu(fe->icbTag.strategyType));
		brelse(bh);
		make_bad_inode(inode);
		return;
	}
	udf_fill_inode(inode, bh);

	brelse(bh);
}

static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)

				use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];

		mark_buffer_dirty(bh);
		brelse(bh);
		return err;
	}


			err = -EIO;
		}
	}
	brelse(bh);
	return err;
}


	return NULL;
}

int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
	kernel_lb_addr eloc, uint32_t elen, int inc)
{
	int adsize;
	short_ad *sad = NULL;

	int8_t etype;
	uint8_t *ptr;

	if (!epos->bh)
		ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
	else
		ptr = epos->bh->b_data + epos->offset;

	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
		adsize = sizeof(short_ad);

	else
		return -1;

	if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize)
	{
		char *sptr, *dptr;
		struct buffer_head *nbh;
		int err, loffset;
		kernel_lb_addr obloc = epos->block;

		if (!(epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
			obloc.partitionReferenceNum, obloc.logicalBlockNum, &err)))
		{
			return -1;
		}
		if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
			epos->block, 0))))
		{
			return -1;
		}

		aed = (struct allocExtDesc *)(nbh->b_data);
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
			aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
		if (epos->offset + adsize > inode->i_sb->s_blocksize)
		{
			loffset = epos->offset;
			aed->lengthAllocDescs = cpu_to_le32(adsize);
			sptr = ptr - adsize;
			dptr = nbh->b_data + sizeof(struct allocExtDesc);
			memcpy(dptr, sptr, adsize);
			epos->offset = sizeof(struct allocExtDesc) + adsize;
		}
		else
		{
			loffset = epos->offset + adsize;
			aed->lengthAllocDescs = cpu_to_le32(0);
			sptr = ptr;
			epos->offset = sizeof(struct allocExtDesc);

			if (epos->bh)
			{
				aed = (struct allocExtDesc *)epos->bh->b_data;
				aed->lengthAllocDescs =
					cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
			}

		}
		if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
				epos->block.logicalBlockNum, sizeof(tag));
		else
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
				epos->block.logicalBlockNum, sizeof(tag));
		switch (UDF_I_ALLOCTYPE(inode))
		{
			case ICBTAG_FLAG_AD_SHORT:

				sad->extLength = cpu_to_le32(
					EXT_NEXT_EXTENT_ALLOCDECS |
					inode->i_sb->s_blocksize);
				sad->extPosition = cpu_to_le32(epos->block.logicalBlockNum);
				break;
			}
			case ICBTAG_FLAG_AD_LONG:

				lad->extLength = cpu_to_le32(
					EXT_NEXT_EXTENT_ALLOCDECS |
					inode->i_sb->s_blocksize);
				lad->extLocation = cpu_to_lelb(epos->block);
				memset(lad->impUse, 0x00, sizeof(lad->impUse));
				break;
			}
		}
		if (epos->bh)
		{
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
				udf_update_tag(epos->bh->b_data, loffset);
			else
				udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
			mark_buffer_dirty_inode(epos->bh, inode);
			brelse(epos->bh);
		}
		else
			mark_inode_dirty(inode);
		epos->bh = nbh;
	}

	etype = udf_write_aext(inode, epos, eloc, elen, inc);

	if (!epos->bh)
	{
		UDF_I_LENALLOC(inode) += adsize;
		mark_inode_dirty(inode);
	}
	else
	{
		aed = (struct allocExtDesc *)epos->bh->b_data;
		aed->lengthAllocDescs =
			cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
			udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
		else
			udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
		mark_buffer_dirty_inode(epos->bh, inode);
	}

	return etype;
}

int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
    kernel_lb_addr eloc, uint32_t elen, int inc)
{
	int adsize;
	uint8_t *ptr;

	if (!epos->bh)
		ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
	else
		ptr = epos->bh->b_data + epos->offset;
		ptr = bh->b_data + *extoffset;
		atomic_inc(&bh->b_count);
	}

	switch (UDF_I_ALLOCTYPE(inode))
	{

			return -1;
	}

	if (epos->bh)
	{
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
		{
			struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
			udf_update_tag(epos->bh->b_data,
				le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
		}
		mark_buffer_dirty_inode(epos->bh, inode);
		udf_release_data(bh);
	}
	else
		mark_inode_dirty(inode);

	if (inc)
		epos->offset += adsize;
	return (elen >> 30);
}

int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
	kernel_lb_addr *eloc, uint32_t *elen, int inc)
{
	int8_t etype;

	while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
		(EXT_NEXT_EXTENT_ALLOCDECS >> 30))
	{
		epos->block = *eloc;
		epos->offset = sizeof(struct allocExtDesc);
		brelse(epos->bh);
		if (!(epos->bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, epos->block, 0))))
		{
			udf_debug("reading block %d failed!\n",
				udf_get_lb_pblock(inode->i_sb, epos->block, 0));
			return -1;
		}
	}

	return etype;
}

int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
	kernel_lb_addr *eloc, uint32_t *elen, int inc)
{
	int alen;
	int8_t etype;
	uint8_t *ptr;

	if (!epos->bh)
	{
		if (!epos->offset)
			epos->offset = udf_file_entry_alloc_offset(inode);
		ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
		alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
	}
	else
	{
		if (!epos->offset)
			epos->offset = sizeof(struct allocExtDesc);
		ptr = epos->bh->b_data + epos->offset;
		alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->lengthAllocDescs);
	}

	switch (UDF_I_ALLOCTYPE(inode))

		{
			short_ad *sad;

			if (!(sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc)))
				return -1;

			etype = le32_to_cpu(sad->extLength) >> 30;

		{
			long_ad *lad;

			if (!(lad = udf_get_filelongad(ptr, alen, &epos->offset, inc)))
				return -1;

			etype = le32_to_cpu(lad->extLength) >> 30;

}

static int8_t
udf_insert_aext(struct inode *inode, struct extent_position epos,
		kernel_lb_addr neloc, uint32_t nelen)
{
	kernel_lb_addr oeloc;
	uint32_t oelen;
	int8_t etype;

	if (epos.bh)
		get_bh(epos.bh);

	while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1)
	{
		udf_write_aext(inode, &epos, neloc, nelen, 1);

		neloc = oeloc;
		nelen = (etype << 30) | oelen;
	}
	udf_add_aext(inode, &epos, neloc, nelen, 1);
	brelse(epos.bh);
	return (nelen >> 30);
}

int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
	kernel_lb_addr eloc, uint32_t elen)
{
	struct extent_position oepos;
	int adsize;
	int oextoffset, adsize;
	int8_t etype;
	struct allocExtDesc *aed;

	if (epos.bh)
	{
		get_bh(epos.bh);
		get_bh(epos.bh);
	}

	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)

	else
		adsize = 0;

	oepos = epos;
	if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
	oextoffset = nextoffset;

	if (udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1) == -1)
		return -1;

	while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1)
	{
		udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);
		if (oepos.bh != epos.bh)
		{
			oepos.block = epos.block;
			brelse(oepos.bh);
			get_bh(epos.bh);
			oepos.bh = epos.bh;
			oepos.offset = epos.offset - adsize;
		}
	}
	memset(&eloc, 0x00, sizeof(kernel_lb_addr));
	elen = 0;

	if (epos.bh != oepos.bh)
	{
		udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);
		udf_write_aext(inode, &oepos, eloc, elen, 1);
		udf_write_aext(inode, &oepos, eloc, elen, 1);
		if (!oepos.bh)
		{
			UDF_I_LENALLOC(inode) -= (adsize * 2);
			mark_inode_dirty(inode);
		}
		else
		{
			aed = (struct allocExtDesc *)oepos.bh->b_data;
			aed->lengthAllocDescs =
				cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2*adsize));
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
				udf_update_tag(oepos.bh->b_data, oepos.offset - (2*adsize));
			else
				udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
			mark_buffer_dirty_inode(oepos.bh, inode);
		}
	}
	else
	{
		udf_write_aext(inode, &oepos, eloc, elen, 1);
		if (!oepos.bh)
		{
			UDF_I_LENALLOC(inode) -= adsize;
			mark_inode_dirty(inode);
		}
		else
		{
			aed = (struct allocExtDesc *)oepos.bh->b_data;
			aed->lengthAllocDescs =
				cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
				udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
			else
				udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
			mark_buffer_dirty_inode(oepos.bh, inode);
		}
	}
	
	brelse(epos.bh);
	brelse(oepos.bh);
	return (elen >> 30);
}

int8_t inode_bmap(struct inode *inode, sector_t block, struct extent_position *pos,
	kernel_lb_addr *eloc, uint32_t *elen, sector_t *offset)
{
	loff_t lbcount = 0, bcount = (loff_t)block << inode->i_sb->s_blocksize_bits;
	int8_t etype;

	if (block < 0)

		return -1;
	}

	pos->offset = 0;
	pos->block = UDF_I_LOCATION(inode);
	pos->bh = NULL;
	*elen = 0;
	*bloc = UDF_I_LOCATION(inode);

	do
	{
		if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1)
		{
			*offset = (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
			UDF_I_LENEXTENTS(inode) = lbcount;
			return -1;
		}
		lbcount += *elen;
	} while (lbcount <= bcount);

	*offset = (bcount + *elen - lbcount) >> inode->i_sb->s_blocksize_bits;

	return etype;
}

long udf_block_map(struct inode *inode, sector_t block)
{
	kernel_lb_addr eloc;
	uint32_t elen;
	sector_t offset;
	struct extent_position epos = { NULL, 0, { 0, 0}};
	int ret;

	lock_kernel();

	if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
		ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
	else
		ret = 0;

	unlock_kernel();
	brelse(epos.bh);

	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
		return udf_fixed_to_variable(ret);




		loc.logicalBlockNum + offset, ident);
}

void udf_release_data(struct buffer_head *bh)
{
	if (bh)
		brelse(bh);
}

void udf_update_tag(char *data, int length)
{
	tag *tptr = (tag *)data;




#include <linux/quotaops.h>
#include <linux/smp_lock.h>
#include <linux/buffer_head.h>
#include <linux/sched.h>

static inline int udf_match(int len1, const char *name1, int len2, const char *name2)
{

	uint8_t lfi;
	uint16_t liu;
	loff_t size;
	kernel_lb_addr eloc;
	uint32_t elen;
	sector_t offset;
	struct extent_position epos = { NULL, 0, { 0, 0}};

	size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
	f_pos = (udf_ext0_offset(dir) >> 2);

	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
		fibh->sbh = fibh->ebh = NULL;
	else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
		&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
	{
		offset >>= dir->i_sb->s_blocksize_bits;
		block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
		if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
		{
			if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
				epos.offset -= sizeof(short_ad);
			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
				epos.offset -= sizeof(long_ad);
		}
		else
			offset = 0;

		if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
		{
			brelse(epos.bh);
			return NULL;
		}
	}
	else
	{
		brelse(epos.bh);
		return NULL;
	}

	while ( (f_pos < size) )
	{
		fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset);

		if (!fi)
		{
			if (fibh->sbh != fibh->ebh)
				brelse(fibh->ebh);
			brelse(fibh->sbh);
			brelse(epos.bh);
			return NULL;
		}


		{
			if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name))
			{
				brelse(epos.bh);
				return fi;
			}
		}
	}
	if (fibh->sbh != fibh->ebh)
		brelse(fibh->ebh);
	brelse(fibh->sbh);
	brelse(epos.bh);
	return NULL;
}


	if (udf_find_entry(dir, dentry, &fibh, &cfi))
	{
		if (fibh.sbh != fibh.ebh)
			brelse(fibh.ebh);
		brelse(fibh.sbh);

		inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation));
		if ( !inode )

	uint8_t lfi;
	uint16_t liu;
	int block;
	kernel_lb_addr eloc;
	uint32_t elen;
	sector_t offset;
	struct extent_position epos = { NULL, 0, { 0, 0 }};

	sb = dir->i_sb;


	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
		fibh->sbh = fibh->ebh = NULL;
	else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
		&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
	{
		offset >>= dir->i_sb->s_blocksize_bits;
		block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
		if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
		{
			if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
				epos.offset -= sizeof(short_ad);
			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
				epos.offset -= sizeof(long_ad);
		}
		else
			offset = 0;

		if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
		{
			brelse(epos.bh);
			*err = -EIO;
			return NULL;
		}


	while ( (f_pos < size) )
	{
		fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset);

		if (!fi)
		{
			if (fibh->sbh != fibh->ebh)
				brelse(fibh->ebh);
			brelse(fibh->sbh);
			brelse(epos.bh);
			*err = -EIO;
			return NULL;
		}

		{
			if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen)
			{
				brelse(epos.bh);
				cfi->descTag.tagSerialNum = cpu_to_le16(1);
				cfi->fileVersionNum = cpu_to_le16(1);
				cfi->fileCharacteristics = 0;

			udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name))
		{
			if (fibh->sbh != fibh->ebh)
				brelse(fibh->ebh);
			brelse(fibh->sbh);
			brelse(epos.bh);
			*err = -EEXIST;
			return NULL;
		}

	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
		sb->s_blocksize - fibh->eoffset < nfidlen)
	{
		brelse(epos.bh);
		epos.bh = NULL;
		fibh->soffset -= udf_ext0_offset(dir);
		fibh->eoffset -= udf_ext0_offset(dir);
		f_pos -= (udf_ext0_offset(dir) >> 2);
		if (fibh->sbh != fibh->ebh)
			brelse(fibh->ebh);
		brelse(fibh->sbh);
		if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err)))
			return NULL;
		epos.block = UDF_I_LOCATION(dir);
		eloc.logicalBlockNum = block;
		eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
		elen = dir->i_sb->s_blocksize;
		epos.offset = udf_file_entry_alloc_offset(dir);
		if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
			epos.offset += sizeof(short_ad);
		else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
			epos.offset += sizeof(long_ad);
	}

	if (sb->s_blocksize - fibh->eoffset >= nfidlen)

		fibh->eoffset += nfidlen;
		if (fibh->sbh != fibh->ebh)
		{
			brelse(fibh->sbh);
			fibh->sbh = fibh->ebh;
		}


		fibh->eoffset += nfidlen - sb->s_blocksize;
		if (fibh->sbh != fibh->ebh)
		{
			brelse(fibh->sbh);
			fibh->sbh = fibh->ebh;
		}



		if (!(fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err)))
		{
			brelse(epos.bh);
			brelse(fibh->sbh);
			return NULL;
		}

		if (!(fibh->soffset))
		{
			if (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
				(EXT_RECORDED_ALLOCATED >> 30))
			{
				block = eloc.logicalBlockNum + ((elen - 1) >>

			else
				block ++;

			brelse(fibh->sbh);
			fibh->sbh = fibh->ebh;
			fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
		}

	cfi->lengthOfImpUse = cpu_to_le16(0);
	if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name))
	{
		brelse(epos.bh);
		dir->i_size += nfidlen;
		if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
			UDF_I_LENALLOC(dir) += nfidlen;

	}
	else
	{
		brelse(epos.bh);
		if (fibh->sbh != fibh->ebh)
			brelse(fibh->ebh);
		brelse(fibh->sbh);
		*err = -EIO;
		return NULL;
	}

		mark_inode_dirty(dir);
	}
	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
	unlock_kernel();
	d_instantiate(dentry, inode);
	return 0;

	mark_inode_dirty(inode);

	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
	d_instantiate(dentry, inode);
	err = 0;
out:

		cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
	cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
	udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
	brelse(fibh.sbh);
	inode->i_mode = S_IFDIR | mode;
	if (dir->i_mode & S_ISGID)
		inode->i_mode |= S_ISGID;

	mark_inode_dirty(dir);
	d_instantiate(dentry, inode);
	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
	err = 0;
out:
	unlock_kernel();

	loff_t f_pos;
	loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
	int block;
	kernel_lb_addr eloc;
	uint32_t elen;
	sector_t offset;
	struct extent_position epos = { NULL, 0, { 0, 0}};

	f_pos = (udf_ext0_offset(dir) >> 2);


	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
		fibh.sbh = fibh.ebh = NULL;
	else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
		&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
	{
		offset >>= dir->i_sb->s_blocksize_bits;
		block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
		if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
		{
			if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
				epos.offset -= sizeof(short_ad);
			else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
				epos.offset -= sizeof(long_ad);
		}
		else
			offset = 0;

		if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))
		{
			brelse(epos.bh);
			return 0;
		}
	}
	else
	{
		brelse(epos.bh);
		return 0;
	}


	while ( (f_pos < size) )
	{
		fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);

		if (!fi)
		{
			if (fibh.sbh != fibh.ebh)
				brelse(fibh.ebh);
			brelse(fibh.sbh);
			brelse(epos.bh);
			return 0;
		}

		if (cfi.lengthFileIdent && (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0)
		{
			if (fibh.sbh != fibh.ebh)
				brelse(fibh.ebh);
			brelse(fibh.sbh);
			brelse(epos.bh);
			return 0;
		}
	}
	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
	brelse(epos.bh);
	return 1;
}


			inode->i_nlink);
	inode->i_nlink = 0;
	inode->i_size = 0;
	inode_dec_link_count(dir);
	dir->i_nlink --;
	inode->i_ctime = dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
	mark_inode_dirty(dir);

end_rmdir:
	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
out:
	unlock_kernel();
	return retval;

		goto end_unlink;
	dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
	mark_inode_dirty(dir);
	inode_dec_link_count(inode);
	mark_inode_dirty(inode);
	inode->i_ctime = dir->i_ctime;
	retval = 0;

end_unlink:
	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
out:
	unlock_kernel();
	return retval;

	struct pathComponent *pc;
	char *compstart;
	struct udf_fileident_bh fibh;
	struct extent_position epos = { NULL,  0, {0, 0}};
	int eoffset, elen = 0;
	struct fileIdentDesc *fi;
	struct fileIdentDesc cfi;


	if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB)
	{
		kernel_lb_addr eloc;
		uint32_t elen;
		uint32_t elen, extoffset;

		block = udf_new_block(inode->i_sb, inode,
			UDF_I_LOCATION(inode).partitionReferenceNum,
			UDF_I_LOCATION(inode).logicalBlockNum, &err);
		if (!block)
			goto out_no_entry;
		epos.block = UDF_I_LOCATION(inode);
		epos.offset = udf_file_entry_alloc_offset(inode);
		epos.bh = NULL;
		eloc.logicalBlockNum = block;
		eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
		elen = inode->i_sb->s_blocksize;
		UDF_I_LENEXTENTS(inode) = elen;
		udf_add_aext(inode, &epos, eloc, elen, 0);
		brelse(epos.bh);
		udf_release_data(bh);

		block = udf_get_pblock(inode->i_sb, block,
			UDF_I_LOCATION(inode).partitionReferenceNum, 0);
		epos.bh = udf_tread(inode->i_sb, block);
		lock_buffer(epos.bh);
		memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
		set_buffer_uptodate(epos.bh);
		unlock_buffer(epos.bh);
		mark_buffer_dirty_inode(epos.bh, inode);
		ea = epos.bh->b_data + udf_ext0_offset(inode);
	}
	else
		ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);

		}
	}

	brelse(epos.bh);
	inode->i_size = elen;
	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
		UDF_I_LENALLOC(inode) = inode->i_size;

		mark_inode_dirty(dir);
	}
	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
	d_instantiate(dentry, inode);
	err = 0;


	return err;

out_no_entry:
	inode_dec_link_count(inode);
	mark_inode_dirty(inode);
	iput(inode);
	goto out;
}

		mark_inode_dirty(dir);
	}
	if (fibh.sbh != fibh.ebh)
		brelse(fibh.ebh);
	brelse(fibh.sbh);
	inode->i_nlink ++;
	inode->i_ctime = current_fs_time(inode->i_sb);
	mark_inode_dirty(inode);

	if ((ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi)))
	{
		if (ofibh.sbh != ofibh.ebh)
			brelse(ofibh.ebh);
		brelse(ofibh.sbh);
	}
	tloc = lelb_to_cpu(ocfi.icb.extLocation);
	if (!ofi || udf_get_lb_pblock(old_dir->i_sb, tloc, 0)

		if (!new_inode)
		{
			if (nfibh.sbh != nfibh.ebh)
				brelse(nfibh.ebh);
			brelse(nfibh.sbh);
			nfi = NULL;
		}
	}


	if (new_inode)
	{
		new_inode->i_nlink--;
		new_inode->i_ctime = current_fs_time(new_inode->i_sb);
		inode_dec_link_count(new_inode);
	}
	old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb);
	mark_inode_dirty(old_dir);

		}
		else
			mark_buffer_dirty_inode(dir_bh, old_inode);
		inode_dec_link_count(old_dir);
		mark_inode_dirty(old_dir);
		if (new_inode)
		{
			inode_dec_link_count(new_inode);
			mark_inode_dirty(new_inode);
		}
		else
		{

	if (ofi)
	{
		if (ofibh.sbh != ofibh.ebh)
			brelse(ofibh.ebh);
		brelse(ofibh.sbh);
	}

	retval = 0;

end_rename:
	brelse(dir_bh);
	if (nfi)
	{
		if (nfibh.sbh != nfibh.ebh)
			brelse(nfibh.ebh);
		brelse(nfibh.sbh);
	}
	unlock_kernel();
	return retval;
}

const struct inode_operations udf_dir_inode_operations = {
	.lookup				= udf_lookup,
	.create				= udf_create,
	.link				= udf_link,

Lines 81-87 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/partition.c (-1 / +1 lines)
81		81
82	loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);	82	loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);
83		83
84	udf_release_data(bh);	84	brelse(bh);
85		85
86	if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition)	86	if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition)
87	{	87	{




	.fs_flags	= FS_REQUIRES_DEV,
};

static struct kmem_cache * udf_inode_cachep;

static struct inode *udf_alloc_inode(struct super_block *sb)
{
	struct udf_inode_info *ei;
	ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
	if (!ei)
		return NULL;


	kmem_cache_free(udf_inode_cachep, UDF_I(inode));
}

static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
{
	struct udf_inode_info *ei = (struct udf_inode_info *) foo;

	ei->i_ext.i_data = NULL;
	inode_init_once(&ei->vfs_inode);
	{
		ei->i_ext.i_data = NULL;
		inode_init_once(&ei->vfs_inode);
	}
}

static int init_inodecache(void)


static void destroy_inodecache(void)
{
	kmem_cache_destroy(udf_inode_cachep);
		printk(KERN_INFO "udf_inode_cache: not all structures were freed\n");
}

/* Superblock operations */
static const struct super_operations udf_sb_ops = {
	.alloc_inode		= udf_alloc_inode,
	.destroy_inode		= udf_destroy_inode,
	.write_inode		= udf_write_inode,


		if (vsd->stdIdent[0] == 0)
		{
			brelse(bh);
			break;
		}
		else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN))

		}
		else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN))
		{
			brelse(bh);
			break;
		}
		else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN))

		{
			nsr03 = sector;
		}
		brelse(bh);
	}

	if (nsr03)

			{
				ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
				location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
				brelse(bh);
			}

			if (ident == TAG_IDENT_AVDP)

				{
					ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
					location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
					brelse(bh);
				}
	
				if (ident == TAG_IDENT_AVDP &&

					{
						ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
						location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
						brelse(bh);
					}
	
					if (ident == TAG_IDENT_AVDP &&

		{
			ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
			location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
			brelse(bh);

			if (ident == TAG_IDENT_AVDP && location == 256)
				UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);

			}
			else
			{
				brelse(bh);
				if ((ident != TAG_IDENT_AVDP) && (i ||
					(ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))
				{

			return 1;
		else if (ident != TAG_IDENT_FSD)
		{
			brelse(bh);
			return 1;
		}
			

						newfileset.logicalBlockNum += 1 +
							((le32_to_cpu(sp->numOfBytes) + sizeof(struct spaceBitmapDesc) - 1)
								>> sb->s_blocksize_bits);
						brelse(bh);
						break;
					}
					case TAG_IDENT_FSD:

					default:
					{
						newfileset.logicalBlockNum ++;
						brelse(bh);
						bh = NULL;
						break;
					}


		UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
		udf_load_fileset(sb, bh, root);
		brelse(bh);
		return 0;
	}
	return 1;

						if (ident != 0 ||
							strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING)))
						{
							brelse(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
							UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;
						}
					}

			udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
		
		if (UDF_SB_LVIDBH(sb) != bh)
			brelse(bh);
		loc.extLength -= sb->s_blocksize;
		loc.extLocation ++;
	}
	if (UDF_SB_LVIDBH(sb) != bh)
		brelse(bh);
}

/*

					done = 1;
				break;
		}
		brelse(bh);
	}
	for (i=0; i<VDS_POS_LENGTH; i++)
	{

					gd = (struct generic_desc *)bh2->b_data;
					if (ident == TAG_IDENT_PD)
						udf_load_partdesc(sb, bh2);
					brelse(bh2);
				}
			}
			brelse(bh);
		}
	}


			reserve_e = reserve_e >> sb->s_blocksize_bits;
			reserve_e += reserve_s;

			brelse(bh);

			/* Process the main & reserve sequences */
			/* responsible for finding the PartitionDesc(s) */


	for (i=0; i<UDF_SB_NUMPARTS(sb); i++)
	{
		switch (UDF_SB_PARTTYPE(sb, i))
		{
			case UDF_VIRTUAL_MAP15:
			case UDF_VIRTUAL_MAP20:


					pos = udf_block_map(UDF_SB_VAT(sb), 0);
					bh = sb_bread(sb, pos);
					if (!bh)
						return 1;
					UDF_SB_TYPEVIRT(sb,i).s_start_offset =
						le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data + udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +
							udf_ext0_offset(UDF_SB_VAT(sb));
					UDF_SB_TYPEVIRT(sb,i).s_num_entries = (UDF_SB_VAT(sb)->i_size -
						UDF_SB_TYPEVIRT(sb,i).s_start_offset) >> 2;
					brelse(bh);
				}
				UDF_SB_PARTROOT(sb,i) = udf_get_pblock(sb, 0, i, 0);
				UDF_SB_PARTLEN(sb,i) = UDF_SB_PARTLEN(sb,ino.partitionReferenceNum);

		goto error_out;
	}

	if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) {
		printk("UDF-fs: Partition marked readonly; forcing readonly mount\n");
		sb->s_flags |= MS_RDONLY;
	}

	if ( udf_find_fileset(sb, &fileset, &rootdir) )
	{
		printk("UDF-fs: No fileset found\n");

		iput(inode);
		goto error_out;
	}
	sb->s_maxbytes = MAX_LFS_FILESIZE;
	return 0;

error_out:

		if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
		{
			for (i=0; i<4; i++)
				brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
		}
	}
#ifdef CONFIG_UDF_NLS

#endif
	if (!(sb->s_flags & MS_RDONLY))
		udf_close_lvid(sb);
	brelse(UDF_SB_LVIDBH(sb));
	UDF_SB_FREE(sb);
	kfree(sbi);
	sb->s_fs_info = NULL;

		sb->s_dirt = 1;
	}
	va_start(args, fmt);
	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
	va_end(args);
	printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
		sb->s_id, function, error_buf);

	va_list args;

	va_start (args, fmt);
	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
	va_end(args);
	printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
		sb->s_id, function, error_buf);

		if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
		{
			for (i=0; i<4; i++)
				brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
		}
	}
#ifdef CONFIG_UDF_NLS

#endif
	if (!(sb->s_flags & MS_RDONLY))
		udf_close_lvid(sb);
	brelse(UDF_SB_LVIDBH(sb));
	UDF_SB_FREE(sb);
	kfree(sb->s_fs_info);
	sb->s_fs_info = NULL;

	}
	else if (ident != TAG_IDENT_SBD)
	{
		brelse(bh);
		printk(KERN_ERR "udf: udf_count_free failed\n");
		goto out;
	}

		}
		if ( bytes )
		{
			brelse(bh);
			newblock = udf_get_lb_pblock(sb, loc, ++block);
			bh = udf_tread(sb, newblock);
			if (!bh)

			ptr = (uint8_t *)bh->b_data;
		}
	}
	brelse(bh);

out:
	unlock_kernel();

udf_count_free_table(struct super_block *sb, struct inode * table)
{
	unsigned int accum = 0;
	uint32_t elen;
	kernel_lb_addr eloc;
	int8_t etype;
	struct extent_position epos;

	lock_kernel();

	epos.block = UDF_I_LOCATION(table);
	epos.offset = sizeof(struct unallocSpaceEntry);
	epos.bh = NULL;

	while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
	{
		accum += (elen >> table->i_sb->s_blocksize_bits);
	brelse(epos.bh);
	udf_release_data(bh);

	unlock_kernel();


Lines 95-101 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/symlink.c (-1 / +1 lines)
95	}	95	}
96		96
97	udf_pc_to_char(inode->i_sb, symlink, inode->i_size, p);	97	udf_pc_to_char(inode->i_sb, symlink, inode->i_size, p);
98	udf_release_data(bh);	98	brelse(bh);
99		99
100	unlock_kernel();	100	unlock_kernel();
101	SetPageUptodate(page);	101	SetPageUptodate(page);

Lines 28-35 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/truncate.c (-126 / +149 lines)
28	#include "udf_i.h"	28	#include "udf_i.h"
29	#include "udf_sb.h"	29	#include "udf_sb.h"
30		30
31	static void extent_trunc(struct inode * inode, kernel_lb_addr bloc, int extoffset,	31	static void extent_trunc(struct inode * inode, struct extent_position *epos,
32	kernel_lb_addr eloc, int8_t etype, uint32_t elen, struct buffer_head *bh, uint32_t nelen)	32	kernel_lb_addr eloc, int8_t etype, uint32_t elen, uint32_t nelen)
33	{	33	{
34	kernel_lb_addr neloc = { 0, 0 };	34	kernel_lb_addr neloc = { 0, 0 };
35	int last_block = (elen + inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;	35	int last_block = (elen + inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
Lines 49-55 Link Here
49		49
50	if (elen != nelen)	50	if (elen != nelen)
51	{	51	{
52	udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 0);	52	udf_write_aext(inode, epos, neloc, nelen, 0);
53	if (last_block - first_block > 0)	53	if (last_block - first_block > 0)
54	{	54	{
55	if (etype == (EXT_RECORDED_ALLOCATED >> 30))	55	if (etype == (EXT_RECORDED_ALLOCATED >> 30))
Lines 61-134 Link Here
61	}	61	}
62	}	62	}
63		63
64	void udf_discard_prealloc(struct inode * inode)	64	/*
		65	* Truncate the last extent to match i_size. This function assumes
		66	* that preallocation extent is already truncated.
		67	*/
		68	void udf_truncate_tail_extent(struct inode *inode)
65	{	69	{
66	kernel_lb_addr bloc, eloc;	70	struct extent_position epos = { NULL, 0, {0, 0}};
67	uint32_t extoffset = 0, elen, nelen;	71	kernel_lb_addr eloc;
		72	uint32_t elen, nelen;
68	uint64_t lbcount = 0;	73	uint64_t lbcount = 0;
69	int8_t etype = -1, netype;	74	int8_t etype = -1, netype;
70	struct buffer_head *bh = NULL;
71	int adsize;	75	int adsize;
72		76
73	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB \|\|	77	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB \|\|
74	inode->i_size == UDF_I_LENEXTENTS(inode))	78	inode->i_size == UDF_I_LENEXTENTS(inode))
75	{	79	return;
		80	/* Are we going to delete the file anyway? */
		81	if (inode->i_nlink == 0)
76	return;	82	return;
77	}
78		83
79	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)	84	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
80	adsize = sizeof(short_ad);	85	adsize = sizeof(short_ad);
81	else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)	86	else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
82	adsize = sizeof(long_ad);	87	adsize = sizeof(long_ad);
83	else	88	else
84	adsize = 0;	89	BUG();
85
86	bloc = UDF_I_LOCATION(inode);
87		90
88	while ((netype = udf_next_aext(inode, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)	91	/* Find the last extent in the file */
		92	while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1)
89	{	93	{
90	etype = netype;	94	etype = netype;
91	lbcount += elen;	95	lbcount += elen;
92	if (lbcount > inode->i_size && lbcount - inode->i_size < inode->i_sb->s_blocksize)	96	if (lbcount > inode->i_size) {
93	{	97	if (lbcount - inode->i_size >= inode->i_sb->s_blocksize)
		98	printk(KERN_WARNING
		99	"udf_truncate_tail_extent(): Too long "
		100	"extent after EOF in inode %u: i_size: "
		101	"%Ld lbcount: %Ld extent %u+%u\n",
		102	(unsigned)inode->i_ino,
		103	(long long)inode->i_size,
		104	(long long)lbcount,
		105	(unsigned)eloc.logicalBlockNum,
		106	(unsigned)elen);
94	nelen = elen - (lbcount - inode->i_size);	107	nelen = elen - (lbcount - inode->i_size);
95	extent_trunc(inode, bloc, extoffset-adsize, eloc, etype, elen, bh, nelen);	108	epos.offset -= adsize;
96	lbcount = inode->i_size;	109	extent_trunc(inode, &epos, eloc, etype, elen, nelen);
		110	epos.offset += adsize;
		111	if (udf_next_aext(inode, &epos, &eloc, &elen, 1) != -1)
		112	printk(KERN_ERR "udf_truncate_tail_extent(): "
		113	"Extent after EOF in inode %u.\n",
		114	(unsigned)inode->i_ino);
		115	break;
97	}	116	}
98	}	117	}
99	if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))	118	/* This inode entry is in-memory only and thus we don't have to mark
100	{	119	* the inode dirty */
101	extoffset -= adsize;	120	UDF_I_LENEXTENTS(inode) = inode->i_size;
		121	brelse(epos.bh);
		122	}
		123
		124	void udf_discard_prealloc(struct inode *inode)
		125	{
		126	struct extent_position epos = { NULL, 0, {0, 0}};
		127	kernel_lb_addr eloc;
		128	uint32_t elen;
		129	uint64_t lbcount = 0;
		130	int8_t etype = -1, netype;
		131	int adsize;
		132
		133	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB \|\|
		134	inode->i_size == UDF_I_LENEXTENTS(inode))
		135	return;
		136
		137	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
		138	adsize = sizeof(short_ad);
		139	else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
		140	adsize = sizeof(long_ad);
		141	else
		142	adsize = 0;
		143
		144	epos.block = UDF_I_LOCATION(inode);
		145
		146	/* Find the last extent in the file */
		147	while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
		148	etype = netype;
		149	lbcount += elen;
		150	}
		151	if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
		152	epos.offset -= adsize;
102	lbcount -= elen;	153	lbcount -= elen;
103	extent_trunc(inode, bloc, extoffset, eloc, etype, elen, bh, 0);	154	extent_trunc(inode, &epos, eloc, etype, elen, 0);
104	if (!bh)	155	if (!epos.bh) {
105	{	156	UDF_I_LENALLOC(inode) = epos.offset - udf_file_entry_alloc_offset(inode);
106	UDF_I_LENALLOC(inode) = extoffset - udf_file_entry_alloc_offset(inode);
107	mark_inode_dirty(inode);	157	mark_inode_dirty(inode);
108	}	158	} else {
109	else	159	struct allocExtDesc aed = (struct allocExtDesc )(epos.bh->b_data);
110	{	160	aed->lengthAllocDescs = cpu_to_le32(epos.offset - sizeof(struct allocExtDesc));
111	struct allocExtDesc aed = (struct allocExtDesc )(bh->b_data);
112	aed->lengthAllocDescs = cpu_to_le32(extoffset - sizeof(struct allocExtDesc));
113	if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) \|\| UDF_SB_UDFREV(inode->i_sb) >= 0x0201)	161	if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) \|\| UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
114	udf_update_tag(bh->b_data, extoffset);	162	udf_update_tag(epos.bh->b_data, epos.offset);
115	else	163	else
116	udf_update_tag(bh->b_data, sizeof(struct allocExtDesc));	164	udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc));
117	mark_buffer_dirty_inode(bh, inode);	165	mark_buffer_dirty_inode(epos.bh, inode);
118	}	166	}
119	}	167	}
		168	/* This inode entry is in-memory only and thus we don't have to mark
		169	* the inode dirty */
120	UDF_I_LENEXTENTS(inode) = lbcount;	170	UDF_I_LENEXTENTS(inode) = lbcount;
121		171	brelse(epos.bh);
122	udf_release_data(bh);
123	}	172	}
124		173
125	void udf_truncate_extents(struct inode * inode)	174	void udf_truncate_extents(struct inode * inode)
126	{	175	{
127	kernel_lb_addr bloc, eloc, neloc = { 0, 0 };	176	struct extent_position epos;
128	uint32_t extoffset, elen, offset, nelen = 0, lelen = 0, lenalloc;	177	kernel_lb_addr eloc, neloc = { 0, 0 };
		178	uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
129	int8_t etype;	179	int8_t etype;
130	int first_block = inode->i_size >> inode->i_sb->s_blocksize_bits;	180	struct super_block *sb = inode->i_sb;
131	struct buffer_head *bh = NULL;	181	sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
		182	loff_t byte_offset;
132	int adsize;	183	int adsize;
133		184
134	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)	185	if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
Lines 136-293 Link Here
136	else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)	187	else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
137	adsize = sizeof(long_ad);	188	adsize = sizeof(long_ad);
138	else	189	else
139	adsize = 0;	190	BUG();
140		191
141	etype = inode_bmap(inode, first_block, &bloc, &extoffset, &eloc, &elen, &offset, &bh);	192	etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
142	offset += (inode->i_size & (inode->i_sb->s_blocksize - 1));	193	byte_offset = (offset << sb->s_blocksize_bits) + (inode->i_size & (sb->s_blocksize-1));
143	if (etype != -1)	194	if (etype != -1)
144	{	195	{
145	extoffset -= adsize;	196	epos.offset -= adsize;
146	extent_trunc(inode, bloc, extoffset, eloc, etype, elen, bh, offset);	197	extent_trunc(inode, &epos, eloc, etype, elen, byte_offset);
147	extoffset += adsize;	198	epos.offset += adsize;
148		199	if (byte_offset)
149	if (offset)	200	lenalloc = epos.offset;
150	lenalloc = extoffset;
151	else	201	else
152	lenalloc = extoffset - adsize;	202	lenalloc = epos.offset - adsize;
153		203
154	if (!bh)	204	if (!epos.bh)
155	lenalloc -= udf_file_entry_alloc_offset(inode);	205	lenalloc -= udf_file_entry_alloc_offset(inode);
156	else	206	else
157	lenalloc -= sizeof(struct allocExtDesc);	207	lenalloc -= sizeof(struct allocExtDesc);
158		208
159	while ((etype = udf_current_aext(inode, &bloc, &extoffset, &eloc, &elen, &bh, 0)) != -1)	209	while ((etype = udf_current_aext(inode, &epos, &eloc, &elen, 0)) != -1)
160	{	210	{
161	if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30))	211	if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
162	{	212	{
163	udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 0);	213	udf_write_aext(inode, &epos, neloc, nelen, 0);
164	extoffset = 0;	214	if (indirect_ext_len)
165	if (lelen)
166	{	215	{
167	if (!bh)	216	/* We managed to free all extents in the
		217	* indirect extent - free it too */
		218	if (!epos.bh)
168	BUG();	219	BUG();
169	else	220	udf_free_blocks(sb, inode, epos.block, 0, indirect_ext_len);
170	memset(bh->b_data, 0x00, sizeof(struct allocExtDesc));
171	udf_free_blocks(inode->i_sb, inode, bloc, 0, lelen);
172	}	221	}
173	else	222	else
174	{	223	{
175	if (!bh)	224	if (!epos.bh)
176	{	225	{
177	UDF_I_LENALLOC(inode) = lenalloc;	226	UDF_I_LENALLOC(inode) = lenalloc;
178	mark_inode_dirty(inode);	227	mark_inode_dirty(inode);
179	}	228	}
180	else	229	else
181	{	230	{
182	struct allocExtDesc aed = (struct allocExtDesc )(bh->b_data);	231	struct allocExtDesc aed = (struct allocExtDesc )(epos.bh->b_data);
183	aed->lengthAllocDescs = cpu_to_le32(lenalloc);	232	aed->lengthAllocDescs = cpu_to_le32(lenalloc);
184	if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) \|\| UDF_SB_UDFREV(inode->i_sb) >= 0x0201)	233	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) \|\| UDF_SB_UDFREV(sb) >= 0x0201)
185	udf_update_tag(bh->b_data, lenalloc +	234	udf_update_tag(epos.bh->b_data, lenalloc +
186	sizeof(struct allocExtDesc));	235	sizeof(struct allocExtDesc));
187	else	236	else
188	udf_update_tag(bh->b_data, sizeof(struct allocExtDesc));	237	udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc));
189	mark_buffer_dirty_inode(bh, inode);	238	mark_buffer_dirty_inode(epos.bh, inode);
190	}	239	}
191	}	240	}
192		241	brelse(epos.bh);
193	udf_release_data(bh);	242	epos.offset = sizeof(struct allocExtDesc);
194	extoffset = sizeof(struct allocExtDesc);	243	epos.block = eloc;
195	bloc = eloc;	244	epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, eloc, 0));
196	bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, bloc, 0));
197	if (elen)	245	if (elen)
198	lelen = (elen + inode->i_sb->s_blocksize - 1) >>	246	indirect_ext_len = (elen +
199	inode->i_sb->s_blocksize_bits;	247	sb->s_blocksize - 1) >>
		248	sb->s_blocksize_bits;
200	else	249	else
201	lelen = 1;	250	indirect_ext_len = 1;
202	}	251	}
203	else	252	else
204	{	253	{
205	extent_trunc(inode, bloc, extoffset, eloc, etype, elen, bh, 0);	254	extent_trunc(inode, &epos, eloc, etype, elen, 0);
206	extoffset += adsize;	255	epos.offset += adsize;
207	}	256	}
208	}	257	}
209		258
210	if (lelen)	259	if (indirect_ext_len)
211	{	260	{
212	if (!bh)	261	if (!epos.bh)
213	BUG();	262	BUG();
214	else	263	udf_free_blocks(sb, inode, epos.block, 0, indirect_ext_len);
215	memset(bh->b_data, 0x00, sizeof(struct allocExtDesc));
216	udf_free_blocks(inode->i_sb, inode, bloc, 0, lelen);
217	}	264	}
218	else	265	else
219	{	266	{
220	if (!bh)	267	if (!epos.bh)
221	{	268	{
222	UDF_I_LENALLOC(inode) = lenalloc;	269	UDF_I_LENALLOC(inode) = lenalloc;
223	mark_inode_dirty(inode);	270	mark_inode_dirty(inode);
224	}	271	}
225	else	272	else
226	{	273	{
227	struct allocExtDesc aed = (struct allocExtDesc )(bh->b_data);	274	struct allocExtDesc aed = (struct allocExtDesc )(epos.bh->b_data);
228	aed->lengthAllocDescs = cpu_to_le32(lenalloc);	275	aed->lengthAllocDescs = cpu_to_le32(lenalloc);
229	if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) \|\| UDF_SB_UDFREV(inode->i_sb) >= 0x0201)	276	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) \|\| UDF_SB_UDFREV(sb) >= 0x0201)
230	udf_update_tag(bh->b_data, lenalloc +	277	udf_update_tag(epos.bh->b_data, lenalloc +
231	sizeof(struct allocExtDesc));	278	sizeof(struct allocExtDesc));
232	else	279	else
233	udf_update_tag(bh->b_data, sizeof(struct allocExtDesc));	280	udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc));
234	mark_buffer_dirty_inode(bh, inode);	281	mark_buffer_dirty_inode(epos.bh, inode);
235	}	282	}
236	}	283	}
237	}	284	}
238	else if (inode->i_size)	285	else if (inode->i_size)
239	{	286	{
240	if (offset)	287	if (byte_offset)
241	{	288	{
		289	kernel_long_ad extent;
		290
242	/*	291	/*
243	* OK, there is not extent covering inode->i_size and	292	* OK, there is not extent covering inode->i_size and
244	* no extent above inode->i_size => truncate is	293	* no extent above inode->i_size => truncate is
245	* extending the file by 'offset'.	294	* extending the file by 'offset' blocks.
246	*/	295	*/
247	if ((!bh && extoffset == udf_file_entry_alloc_offset(inode)) \|\|	296	if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) \|\|
248	(bh && extoffset == sizeof(struct allocExtDesc))) {	297	(epos.bh && epos.offset == sizeof(struct allocExtDesc))) {
249	/* File has no extents at all! */	298	/* File has no extents at all or has empty last
250	memset(&eloc, 0x00, sizeof(kernel_lb_addr));	299	* indirect extent! Create a fake extent... */
251	elen = EXT_NOT_RECORDED_NOT_ALLOCATED \| offset;	300	extent.extLocation.logicalBlockNum = 0;
252	udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 1);	301	extent.extLocation.partitionReferenceNum = 0;
		302	extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
253	}	303	}
254	else {	304	else {
255	extoffset -= adsize;	305	epos.offset -= adsize;
256	etype = udf_next_aext(inode, &bloc, &extoffset, &eloc, &elen, &bh, 1);	306	etype = udf_next_aext(inode, &epos,
257	if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))	307	&extent.extLocation, &extent.extLength, 0);
258	{	308	extent.extLength \|= etype << 30;
259	extoffset -= adsize;
260	elen = EXT_NOT_RECORDED_NOT_ALLOCATED \| (elen + offset);
261	udf_write_aext(inode, bloc, &extoffset, eloc, elen, bh, 0);
262	}
263	else if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
264	{
265	kernel_lb_addr neloc = { 0, 0 };
266	extoffset -= adsize;
267	nelen = EXT_NOT_RECORDED_NOT_ALLOCATED \|
268	((elen + offset + inode->i_sb->s_blocksize - 1) &
269	~(inode->i_sb->s_blocksize - 1));
270	udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 1);
271	udf_add_aext(inode, &bloc, &extoffset, eloc, (etype << 30) \| elen, &bh, 1);
272	}
273	else
274	{
275	if (elen & (inode->i_sb->s_blocksize - 1))
276	{
277	extoffset -= adsize;
278	elen = EXT_RECORDED_ALLOCATED \|
279	((elen + inode->i_sb->s_blocksize - 1) &
280	~(inode->i_sb->s_blocksize - 1));
281	udf_write_aext(inode, bloc, &extoffset, eloc, elen, bh, 1);
282	}
283	memset(&eloc, 0x00, sizeof(kernel_lb_addr));
284	elen = EXT_NOT_RECORDED_NOT_ALLOCATED \| offset;
285	udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 1);
286	}
287	}	309	}
		310	udf_extend_file(inode, &epos, &extent, offset+((inode->i_size & (sb->s_blocksize-1)) != 0));
288	}	311	}
289	}	312	}
290	UDF_I_LENEXTENTS(inode) = inode->i_size;	313	UDF_I_LENEXTENTS(inode) = inode->i_size;
291		314
292	udf_release_data(bh);	315	brelse(epos.bh);
293	}	316	}

Lines 42-50 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/udfdecl.h (-11 / +19 lines)
42	struct buffer_head;	42	struct buffer_head;
43	struct super_block;	43	struct super_block;
44		44
45	extern struct inode_operations udf_dir_inode_operations;	45	extern const struct inode_operations udf_dir_inode_operations;
46	extern const struct file_operations udf_dir_operations;	46	extern const struct file_operations udf_dir_operations;
47	extern struct inode_operations udf_file_inode_operations;	47	extern const struct inode_operations udf_file_inode_operations;
48	extern const struct file_operations udf_file_operations;	48	extern const struct file_operations udf_file_operations;
49	extern const struct address_space_operations udf_aops;	49	extern const struct address_space_operations udf_aops;
50	extern const struct address_space_operations udf_adinicb_aops;	50	extern const struct address_space_operations udf_adinicb_aops;
Lines 77-82 Link Here
77	uint8_t u_len;	77	uint8_t u_len;
78	};	78	};
79		79
		80	struct extent_position {
		81	struct buffer_head *bh;
		82	uint32_t offset;
		83	kernel_lb_addr block;
		84	};
		85
		86
80	/* super.c */	87	/* super.c */
81	extern void udf_error(struct super_block , const char , const char *, ...);	88	extern void udf_error(struct super_block , const char , const char *, ...);
82	extern void udf_warning(struct super_block , const char , const char *, ...);	89	extern void udf_warning(struct super_block , const char , const char *, ...);
Lines 98-110 Link Here
98	extern void udf_delete_inode(struct inode *);	105	extern void udf_delete_inode(struct inode *);
99	extern void udf_clear_inode(struct inode *);	106	extern void udf_clear_inode(struct inode *);
100	extern int udf_write_inode(struct inode *, int);	107	extern int udf_write_inode(struct inode *, int);
101	extern long udf_block_map(struct inode *, long);	108	extern long udf_block_map(struct inode *, sector_t);
102	extern int8_t inode_bmap(struct inode , int, kernel_lb_addr , uint32_t , kernel_lb_addr , uint32_t , uint32_t , struct buffer_head **);	109	extern int udf_extend_file(struct inode , struct extent_position , kernel_long_ad *, sector_t);
103	extern int8_t udf_add_aext(struct inode , kernel_lb_addr , int , kernel_lb_addr, uint32_t, struct buffer_head *, int);	110	extern int8_t inode_bmap(struct inode , sector_t, struct extent_position , kernel_lb_addr , uint32_t , sector_t *);
104	extern int8_t udf_write_aext(struct inode , kernel_lb_addr, int , kernel_lb_addr, uint32_t, struct buffer_head *, int);	111	extern int8_t udf_add_aext(struct inode , struct extent_position , kernel_lb_addr, uint32_t, int);
105	extern int8_t udf_delete_aext(struct inode , kernel_lb_addr, int, kernel_lb_addr, uint32_t, struct buffer_head );	112	extern int8_t udf_write_aext(struct inode , struct extent_position , kernel_lb_addr, uint32_t, int);
106	extern int8_t udf_next_aext(struct inode , kernel_lb_addr , int , kernel_lb_addr , uint32_t , struct buffer_head *, int);	113	extern int8_t udf_delete_aext(struct inode *, struct extent_position, kernel_lb_addr, uint32_t);
107	extern int8_t udf_current_aext(struct inode , kernel_lb_addr , int , kernel_lb_addr , uint32_t , struct buffer_head *, int);	114	extern int8_t udf_next_aext(struct inode , struct extent_position , kernel_lb_addr , uint32_t , int);
		115	extern int8_t udf_current_aext(struct inode , struct extent_position , kernel_lb_addr , uint32_t , int);
108		116
109	/* misc.c */	117	/* misc.c */
110	extern struct buffer_head udf_tgetblk(struct super_block , int);	118	extern struct buffer_head udf_tgetblk(struct super_block , int);
Lines 113-119 Link Here
113	extern struct genericFormat udf_get_extendedattr(struct inode , uint32_t, uint8_t);	121	extern struct genericFormat udf_get_extendedattr(struct inode , uint32_t, uint8_t);
114	extern struct buffer_head udf_read_tagged(struct super_block , uint32_t, uint32_t, uint16_t *);	122	extern struct buffer_head udf_read_tagged(struct super_block , uint32_t, uint32_t, uint16_t *);
115	extern struct buffer_head udf_read_ptagged(struct super_block , kernel_lb_addr, uint32_t, uint16_t *);	123	extern struct buffer_head udf_read_ptagged(struct super_block , kernel_lb_addr, uint32_t, uint16_t *);
116	extern void udf_release_data(struct buffer_head *);
117	extern void udf_update_tag(char *, int);	124	extern void udf_update_tag(char *, int);
118	extern void udf_new_tag(char *, uint16_t, uint16_t, uint16_t, uint32_t, int);	125	extern void udf_new_tag(char *, uint16_t, uint16_t, uint16_t, uint32_t, int);
119		126
Lines 139-144 Link Here
139	extern struct inode * udf_new_inode (struct inode , int, int );	146	extern struct inode * udf_new_inode (struct inode , int, int );
140		147
141	/* truncate.c */	148	/* truncate.c */
		149	extern void udf_truncate_tail_extent(struct inode *);
142	extern void udf_discard_prealloc(struct inode *);	150	extern void udf_discard_prealloc(struct inode *);
143	extern void udf_truncate_extents(struct inode *);	151	extern void udf_truncate_extents(struct inode *);
144		152
Lines 151-157 Link Here
151	extern int udf_fsync_file(struct file , struct dentry , int);	159	extern int udf_fsync_file(struct file , struct dentry , int);
152		160
153	/* directory.c */	161	/* directory.c */
154	extern struct fileIdentDesc * udf_fileident_read(struct inode , loff_t , struct udf_fileident_bh , struct fileIdentDesc , kernel_lb_addr , uint32_t , kernel_lb_addr , uint32_t , uint32_t , struct buffer_head *);	162	extern struct fileIdentDesc * udf_fileident_read(struct inode , loff_t , struct udf_fileident_bh , struct fileIdentDesc , struct extent_position , kernel_lb_addr , uint32_t , sector_t );
155	extern struct fileIdentDesc * udf_get_fileident(void * buffer, int bufsize, int * offset);	163	extern struct fileIdentDesc * udf_get_fileident(void * buffer, int bufsize, int * offset);
156	extern long_ad * udf_get_filelongad(uint8_t , int, int , int);	164	extern long_ad * udf_get_filelongad(uint8_t , int, int , int);
157	extern short_ad * udf_get_fileshortad(uint8_t , int, int , int);	165	extern short_ad * udf_get_fileshortad(uint8_t , int, int , int);

Lines 93-99 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/udf_sb.h (-1 / +1 lines)
93	for (i=0; i<nr_groups; i++)\	93	for (i=0; i<nr_groups; i++)\
94	{\	94	{\
95	if (UDF_SB_BITMAP(X,Y,Z,i))\	95	if (UDF_SB_BITMAP(X,Y,Z,i))\
96	udf_release_data(UDF_SB_BITMAP(X,Y,Z,i));\	96	brelse(UDF_SB_BITMAP(X,Y,Z,i));\
97	}\	97	}\
98	if (size <= PAGE_SIZE)\	98	if (size <= PAGE_SIZE)\
99	kfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\	99	kfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\

Return to bug 12565

Lines 427-435 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/balloc.c (-90 / +87 lines)
427	{	427	{
428	struct udf_sb_info *sbi = UDF_SB(sb);	428	struct udf_sb_info *sbi = UDF_SB(sb);
429	uint32_t start, end;	429	uint32_t start, end;
430	uint32_t nextoffset, oextoffset, elen;	430	uint32_t elen;
431	kernel_lb_addr nbloc, obloc, eloc;	431	kernel_lb_addr eloc;
432	struct buffer_head obh, nbh;	432	struct extent_position oepos, epos;
433	int8_t etype;	433	int8_t etype;
434	int i;	434	int i;
435		435
Lines 457-470 Link Here
457	start = bloc.logicalBlockNum + offset;	457	start = bloc.logicalBlockNum + offset;
458	end = bloc.logicalBlockNum + offset + count - 1;	458	end = bloc.logicalBlockNum + offset + count - 1;
459		459
460	oextoffset = nextoffset = sizeof(struct unallocSpaceEntry);	460	epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
461	elen = 0;	461	elen = 0;
462	obloc = nbloc = UDF_I_LOCATION(table);	462	epos.block = oepos.block = UDF_I_LOCATION(table);
463		463	epos.bh = oepos.bh = NULL;
464	obh = nbh = NULL;
465		464
466	while (count && (etype =	465	while (count && (etype =
467	udf_next_aext(table, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1)	466	udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
468	{	467	{
469	if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==	468	if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==
470	start))	469	start))
Lines 482-488 Link Here
482	start += count;	481	start += count;
483	count = 0;	482	count = 0;
484	}	483	}
485	udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);	484	udf_write_aext(table, &oepos, eloc, elen, 1);
486	}	485	}
487	else if (eloc.logicalBlockNum == (end + 1))	486	else if (eloc.logicalBlockNum == (end + 1))
488	{	487	{
Lines 502-521 Link Here
502	end -= count;	501	end -= count;
503	count = 0;	502	count = 0;
504	}	503	}
505	udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);	504	udf_write_aext(table, &oepos, eloc, elen, 1);
506	}	505	}
507		506
508	if (nbh != obh)	507	if (epos.bh != oepos.bh)
509	{	508	{
510	i = -1;	509	i = -1;
511	obloc = nbloc;	510	oepos.block = epos.block;
512	udf_release_data(obh);	511	brelse(oepos.bh);
513	atomic_inc(&nbh->b_count);	512	get_bh(epos.bh);
514	obh = nbh;	513	oepos.bh = epos.bh;
515	oextoffset = 0;	514	oepos.offset = 0;
516	}	515	}
517	else	516	else
518	oextoffset = nextoffset;	517	oepos.offset = epos.offset;
519	}	518	}
520		519
521	if (count)	520	if (count)
Lines 547-601 Link Here
547	adsize = sizeof(long_ad);	546	adsize = sizeof(long_ad);
548	else	547	else
549	{	548	{
550	udf_release_data(obh);	549	brelse(oepos.bh);
551	udf_release_data(nbh);	550	brelse(epos.bh);
552	goto error_return;	551	goto error_return;
553	}	552	}
554		553
555	if (nextoffset + (2 * adsize) > sb->s_blocksize)	554	if (epos.offset + (2 * adsize) > sb->s_blocksize)
556	{	555	{
557	char sptr, dptr;	556	char sptr, dptr;
558	int loffset;	557	int loffset;
559		558
560	udf_release_data(obh);	559	brelse(oepos.bh);
561	obh = nbh;	560	oepos = epos;
562	obloc = nbloc;
563	oextoffset = nextoffset;
564		561
565	/* Steal a block from the extent being free'd */	562	/* Steal a block from the extent being free'd */
566	nbloc.logicalBlockNum = eloc.logicalBlockNum;	563	epos.block.logicalBlockNum = eloc.logicalBlockNum;
567	eloc.logicalBlockNum ++;	564	eloc.logicalBlockNum ++;
568	elen -= sb->s_blocksize;	565	elen -= sb->s_blocksize;
569		566
570	if (!(nbh = udf_tread(sb,	567	if (!(epos.bh = udf_tread(sb,
571	udf_get_lb_pblock(sb, nbloc, 0))))	568	udf_get_lb_pblock(sb, epos.block, 0))))
572	{	569	{
573	udf_release_data(obh);	570	brelse(oepos.bh);
574	goto error_return;	571	goto error_return;
575	}	572	}
576	aed = (struct allocExtDesc *)(nbh->b_data);	573	aed = (struct allocExtDesc *)(epos.bh->b_data);
577	aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);	574	aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);
578	if (nextoffset + adsize > sb->s_blocksize)	575	if (epos.offset + adsize > sb->s_blocksize)
579	{	576	{
580	loffset = nextoffset;	577	loffset = epos.offset;
581	aed->lengthAllocDescs = cpu_to_le32(adsize);	578	aed->lengthAllocDescs = cpu_to_le32(adsize);
582	sptr = UDF_I_DATA(inode) + nextoffset -	579	sptr = UDF_I_DATA(inode) + epos.offset -
583	udf_file_entry_alloc_offset(inode) +	580	udf_file_entry_alloc_offset(inode) +
584	UDF_I_LENEATTR(inode) - adsize;	581	UDF_I_LENEATTR(inode) - adsize;
585	dptr = nbh->b_data + sizeof(struct allocExtDesc);	582	dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
586	memcpy(dptr, sptr, adsize);	583	memcpy(dptr, sptr, adsize);
587	nextoffset = sizeof(struct allocExtDesc) + adsize;	584	epos.offset = sizeof(struct allocExtDesc) + adsize;
588	}	585	}
589	else	586	else
590	{	587	{
591	loffset = nextoffset + adsize;	588	loffset = epos.offset + adsize;
592	aed->lengthAllocDescs = cpu_to_le32(0);	589	aed->lengthAllocDescs = cpu_to_le32(0);
593	sptr = (obh)->b_data + nextoffset;	590	sptr = oepos.bh->b_data + epos.offset;
594	nextoffset = sizeof(struct allocExtDesc);	591	epos.offset = sizeof(struct allocExtDesc);
595		592
596	if (obh)	593	if (oepos.bh)
597	{	594	{
598	aed = (struct allocExtDesc *)(obh)->b_data;	595	aed = (struct allocExtDesc *)oepos.bh->b_data;
599	aed->lengthAllocDescs =	596	aed->lengthAllocDescs =
600	cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);	597	cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
601	}	598	}
Lines 606-616 Link Here
606	}	603	}
607	}	604	}
608	if (UDF_SB_UDFREV(sb) >= 0x0200)	605	if (UDF_SB_UDFREV(sb) >= 0x0200)
609	udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,	606	udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
610	nbloc.logicalBlockNum, sizeof(tag));	607	epos.block.logicalBlockNum, sizeof(tag));
611	else	608	else
612	udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,	609	udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,
613	nbloc.logicalBlockNum, sizeof(tag));	610	epos.block.logicalBlockNum, sizeof(tag));
614	switch (UDF_I_ALLOCTYPE(table))	611	switch (UDF_I_ALLOCTYPE(table))
615	{	612	{
616	case ICBTAG_FLAG_AD_SHORT:	613	case ICBTAG_FLAG_AD_SHORT:
Lines 619-625 Link Here
619	sad->extLength = cpu_to_le32(	616	sad->extLength = cpu_to_le32(
620	EXT_NEXT_EXTENT_ALLOCDECS \|	617	EXT_NEXT_EXTENT_ALLOCDECS \|
621	sb->s_blocksize);	618	sb->s_blocksize);
622	sad->extPosition = cpu_to_le32(nbloc.logicalBlockNum);	619	sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);
623	break;	620	break;
624	}	621	}
625	case ICBTAG_FLAG_AD_LONG:	622	case ICBTAG_FLAG_AD_LONG:
Lines 628-641 Link Here
628	lad->extLength = cpu_to_le32(	625	lad->extLength = cpu_to_le32(
629	EXT_NEXT_EXTENT_ALLOCDECS \|	626	EXT_NEXT_EXTENT_ALLOCDECS \|
630	sb->s_blocksize);	627	sb->s_blocksize);
631	lad->extLocation = cpu_to_lelb(nbloc);	628	lad->extLocation = cpu_to_lelb(epos.block);
632	break;	629	break;
633	}	630	}
634	}	631	}
635	if (obh)	632	if (oepos.bh)
636	{	633	{
637	udf_update_tag(obh->b_data, loffset);	634	udf_update_tag(oepos.bh->b_data, loffset);
638	mark_buffer_dirty(obh);	635	mark_buffer_dirty(oepos.bh);
639	}	636	}
640	else	637	else
641	mark_inode_dirty(table);	638	mark_inode_dirty(table);
Lines 643-668 Link Here
643		640
644	if (elen) /* It's possible that stealing the block emptied the extent */	641	if (elen) /* It's possible that stealing the block emptied the extent */
645	{	642	{
646	udf_write_aext(table, nbloc, &nextoffset, eloc, elen, nbh, 1);	643	udf_write_aext(table, &epos, eloc, elen, 1);
647		644
648	if (!nbh)	645	if (!epos.bh)
649	{	646	{
650	UDF_I_LENALLOC(table) += adsize;	647	UDF_I_LENALLOC(table) += adsize;
651	mark_inode_dirty(table);	648	mark_inode_dirty(table);
652	}	649	}
653	else	650	else
654	{	651	{
655	aed = (struct allocExtDesc *)nbh->b_data;	652	aed = (struct allocExtDesc *)epos.bh->b_data;
656	aed->lengthAllocDescs =	653	aed->lengthAllocDescs =
657	cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);	654	cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
658	udf_update_tag(nbh->b_data, nextoffset);	655	udf_update_tag(epos.bh->b_data, epos.offset);
659	mark_buffer_dirty(nbh);	656	mark_buffer_dirty(epos.bh);
660	}	657	}
661	}	658	}
662	}	659	}
663		660
664	udf_release_data(nbh);	661	brelse(epos.bh);
665	udf_release_data(obh);	662	brelse(oepos.bh);
666		663
667	error_return:	664	error_return:
668	sb->s_dirt = 1;	665	sb->s_dirt = 1;
Lines 677-685 Link Here
677	{	674	{
678	struct udf_sb_info *sbi = UDF_SB(sb);	675	struct udf_sb_info *sbi = UDF_SB(sb);
679	int alloc_count = 0;	676	int alloc_count = 0;
680	uint32_t extoffset, elen, adsize;	677	uint32_t elen, adsize;
681	kernel_lb_addr bloc, eloc;	678	kernel_lb_addr eloc;
682	struct buffer_head *bh;	679	struct extent_position epos;
683	int8_t etype = -1;	680	int8_t etype = -1;
684		681
685	if (first_block < 0 \|\| first_block >= UDF_SB_PARTLEN(sb, partition))	682	if (first_block < 0 \|\| first_block >= UDF_SB_PARTLEN(sb, partition))
Lines 693-706 Link Here
693	return 0;	690	return 0;
694		691
695	mutex_lock(&sbi->s_alloc_mutex);	692	mutex_lock(&sbi->s_alloc_mutex);
696	extoffset = sizeof(struct unallocSpaceEntry);	693	epos.offset = sizeof(struct unallocSpaceEntry);
697	bloc = UDF_I_LOCATION(table);	694	epos.block = UDF_I_LOCATION(table);
698		695	epos.bh = NULL;
699	bh = NULL;
700	eloc.logicalBlockNum = 0xFFFFFFFF;	696	eloc.logicalBlockNum = 0xFFFFFFFF;
701		697
702	while (first_block != eloc.logicalBlockNum && (etype =	698	while (first_block != eloc.logicalBlockNum && (etype =
703	udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)	699	udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
704	{	700	{
705	udf_debug("eloc=%d, elen=%d, first_block=%d\n",	701	udf_debug("eloc=%d, elen=%d, first_block=%d\n",
706	eloc.logicalBlockNum, elen, first_block);	702	eloc.logicalBlockNum, elen, first_block);
Lines 709-715 Link Here
709		705
710	if (first_block == eloc.logicalBlockNum)	706	if (first_block == eloc.logicalBlockNum)
711	{	707	{
712	extoffset -= adsize;	708	epos.offset -= adsize;
713		709
714	alloc_count = (elen >> sb->s_blocksize_bits);	710	alloc_count = (elen >> sb->s_blocksize_bits);
715	if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count))	711	if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count))
Lines 719-733 Link Here
719	alloc_count = block_count;	715	alloc_count = block_count;
720	eloc.logicalBlockNum += alloc_count;	716	eloc.logicalBlockNum += alloc_count;
721	elen -= (alloc_count << sb->s_blocksize_bits);	717	elen -= (alloc_count << sb->s_blocksize_bits);
722	udf_write_aext(table, bloc, &extoffset, eloc, (etype << 30) \| elen, bh, 1);	718	udf_write_aext(table, &epos, eloc, (etype << 30) \| elen, 1);
723	}	719	}
724	else	720	else
725	udf_delete_aext(table, bloc, extoffset, eloc, (etype << 30) \| elen, bh);	721	udf_delete_aext(table, epos, eloc, (etype << 30) \| elen);
726	}	722	}
727	else	723	else
728	alloc_count = 0;	724	alloc_count = 0;
729		725
730	udf_release_data(bh);	726	brelse(epos.bh);
731		727
732	if (alloc_count && UDF_SB_LVIDBH(sb))	728	if (alloc_count && UDF_SB_LVIDBH(sb))
733	{	729	{
Lines 747-755 Link Here
747	struct udf_sb_info *sbi = UDF_SB(sb);	743	struct udf_sb_info *sbi = UDF_SB(sb);
748	uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;	744	uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
749	uint32_t newblock = 0, adsize;	745	uint32_t newblock = 0, adsize;
750	uint32_t extoffset, goal_extoffset, elen, goal_elen = 0;	746	uint32_t elen, goal_elen = 0;
751	kernel_lb_addr bloc, goal_bloc, eloc, goal_eloc;	747	kernel_lb_addr eloc, goal_eloc;
752	struct buffer_head bh, goal_bh;	748	struct extent_position epos, goal_epos;
753	int8_t etype;	749	int8_t etype;
754		750
755	*err = -ENOSPC;	751	*err = -ENOSPC;
Lines 770-783 Link Here
770	We store the buffer_head, bloc, and extoffset of the current closest	766	We store the buffer_head, bloc, and extoffset of the current closest
771	match and use that when we are done.	767	match and use that when we are done.
772	*/	768	*/
773		769	epos.offset = sizeof(struct unallocSpaceEntry);
774	extoffset = sizeof(struct unallocSpaceEntry);	770	epos.block = UDF_I_LOCATION(table);
775	bloc = UDF_I_LOCATION(table);	771	epos.bh = goal_epos.bh = NULL;
776
777	goal_bh = bh = NULL;
778		772
779	while (spread && (etype =	773	while (spread && (etype =
780	udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)	774	udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
781	{	775	{
782	if (goal >= eloc.logicalBlockNum)	776	if (goal >= eloc.logicalBlockNum)
783	{	777	{
Lines 793-816 Link Here
793	if (nspread < spread)	787	if (nspread < spread)
794	{	788	{
795	spread = nspread;	789	spread = nspread;
796	if (goal_bh != bh)	790	if (goal_epos.bh != epos.bh)
797	{	791	{
798	udf_release_data(goal_bh);	792	brelse(goal_epos.bh);
799	goal_bh = bh;	793	goal_epos.bh = epos.bh;
800	atomic_inc(&goal_bh->b_count);	794	get_bh(goal_epos.bh);
801	}	795	}
802	goal_bloc = bloc;	796	goal_epos.block = epos.block;
803	goal_extoffset = extoffset - adsize;	797	goal_epos.offset = epos.offset - adsize;
804	goal_eloc = eloc;	798	goal_eloc = eloc;
805	goal_elen = (etype << 30) \| elen;	799	goal_elen = (etype << 30) \| elen;
806	}	800	}
807	}	801	}
808		802
809	udf_release_data(bh);	803	brelse(epos.bh);
810		804
811	if (spread == 0xFFFFFFFF)	805	if (spread == 0xFFFFFFFF)
812	{	806	{
813	udf_release_data(goal_bh);	807	brelse(goal_epos.bh);
814	mutex_unlock(&sbi->s_alloc_mutex);	808	mutex_unlock(&sbi->s_alloc_mutex);
815	return 0;	809	return 0;
816	}	810	}
Lines 826-842 Link Here
826		820
827	if (inode && DQUOT_ALLOC_BLOCK(inode, 1))	821	if (inode && DQUOT_ALLOC_BLOCK(inode, 1))
828	{	822	{
829	udf_release_data(goal_bh);	823	brelse(goal_epos.bh);
830	mutex_unlock(&sbi->s_alloc_mutex);	824	mutex_unlock(&sbi->s_alloc_mutex);
831	*err = -EDQUOT;	825	*err = -EDQUOT;
832	return 0;	826	return 0;
833	}	827	}
834		828
835	if (goal_elen)	829	if (goal_elen)
836	udf_write_aext(table, goal_bloc, &goal_extoffset, goal_eloc, goal_elen, goal_bh, 1);	830	udf_write_aext(table, &goal_epos, goal_eloc, goal_elen, 1);
837	else	831	else
838	udf_delete_aext(table, goal_bloc, goal_extoffset, goal_eloc, goal_elen, goal_bh);	832	udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
839	udf_release_data(goal_bh);	833	brelse(goal_epos.bh);
840		834
841	if (UDF_SB_LVIDBH(sb))	835	if (UDF_SB_LVIDBH(sb))
842	{	836	{
Lines 921-931 Link Here
921	struct inode * inode,	915	struct inode * inode,
922	uint16_t partition, uint32_t goal, int *err)	916	uint16_t partition, uint32_t goal, int *err)
923	{	917	{
		918	int ret;
		919
924	if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP)	920	if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP)
925	{	921	{
926	return udf_bitmap_new_block(sb, inode,	922	ret = udf_bitmap_new_block(sb, inode,
927	UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,	923	UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
928	partition, goal, err);	924	partition, goal, err);
		925	return ret;
929	}	926	}
930	else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE)	927	else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE)
931	{	928	{

Lines 111-121 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/dir.c (-19 / +20 lines)
111	uint16_t liu;	111	uint16_t liu;
112	uint8_t lfi;	112	uint8_t lfi;
113	loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;	113	loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
114	struct buffer_head * bh = NULL, * tmp, * bha[16];	114	struct buffer_head tmp, bha[16];
115	kernel_lb_addr bloc, eloc;	115	kernel_lb_addr eloc;
116	uint32_t extoffset, elen, offset;	116	uint32_t elen;
		117	sector_t offset;
117	int i, num;	118	int i, num;
118	unsigned int dt_type;	119	unsigned int dt_type;
		120	struct extent_position epos = { NULL, 0, {0, 0}};
119		121
120	if (nf_pos >= size)	122	if (nf_pos >= size)
121	return 0;	123	return 0;
Lines 127-149 Link Here
127	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)	129	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
128	fibh.sbh = fibh.ebh = NULL;	130	fibh.sbh = fibh.ebh = NULL;
129	else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),	131	else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
130	&bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))	132	&epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
131	{	133	{
132	offset >>= dir->i_sb->s_blocksize_bits;
133	block = udf_get_lb_pblock(dir->i_sb, eloc, offset);	134	block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
134	if ((++offset << dir->i_sb->s_blocksize_bits) < elen)	135	if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
135	{	136	{
136	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)	137	if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
137	extoffset -= sizeof(short_ad);	138	epos.offset -= sizeof(short_ad);
138	else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)	139	else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
139	extoffset -= sizeof(long_ad);	140	epos.offset -= sizeof(long_ad);
140	}	141	}
141	else	142	else
142	offset = 0;	143	offset = 0;
143		144
144	if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))	145	if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))
145	{	146	{
146	udf_release_data(bh);	147	brelse(epos.bh);
147	return -EIO;	148	return -EIO;
148	}	149	}
149		150
Lines 171-177 Link Here
171	}	172	}
172	else	173	else
173	{	174	{
174	udf_release_data(bh);	175	brelse(epos.bh);
175	return -ENOENT;	176	return -ENOENT;
176	}	177	}
177		178
Lines 179-192 Link Here
179	{	180	{
180	filp->f_pos = nf_pos + 1;	181	filp->f_pos = nf_pos + 1;
181		182
182	fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);	183	fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);
183		184
184	if (!fi)	185	if (!fi)
185	{	186	{
186	if (fibh.sbh != fibh.ebh)	187	if (fibh.sbh != fibh.ebh)
187	udf_release_data(fibh.ebh);	188	brelse(fibh.ebh);
188	udf_release_data(fibh.sbh);	189	brelse(fibh.sbh);
189	udf_release_data(bh);	190	brelse(epos.bh);
190	return 0;	191	return 0;
191	}	192	}
192		193
Lines 244-252 Link Here
244	if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0)	245	if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0)
245	{	246	{
246	if (fibh.sbh != fibh.ebh)	247	if (fibh.sbh != fibh.ebh)
247	udf_release_data(fibh.ebh);	248	brelse(fibh.ebh);
248	udf_release_data(fibh.sbh);	249	brelse(fibh.sbh);
249	udf_release_data(bh);	250	brelse(epos.bh);
250	return 0;	251	return 0;
251	}	252	}
252	}	253	}
Lines 255-263 Link Here
255	filp->f_pos = nf_pos + 1;	256	filp->f_pos = nf_pos + 1;
256		257
257	if (fibh.sbh != fibh.ebh)	258	if (fibh.sbh != fibh.ebh)
258	udf_release_data(fibh.ebh);	259	brelse(fibh.ebh);
259	udf_release_data(fibh.sbh);	260	brelse(fibh.sbh);
260	udf_release_data(bh);	261	brelse(epos.bh);
261		262
262	return 0;	263	return 0;
263	}	264	}

Lines 36-49 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/directory.c (-17 / +13 lines)
36		36
37	if (!ad)	37	if (!ad)
38	{	38	{
39	udf_release_data(*bh);	39	brelse(*bh);
40	*error = 1;	40	*error = 1;
41	return NULL;	41	return NULL;
42	}	42	}
43		43
44	if (*offset == dir->i_sb->s_blocksize)	44	if (*offset == dir->i_sb->s_blocksize)
45	{	45	{
46	udf_release_data(*bh);	46	brelse(*bh);
47	block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);	47	block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
48	if (!block)	48	if (!block)
49	return NULL;	49	return NULL;
Lines 57-63 Link Here
57	remainder = dir->i_sb->s_blocksize - loffset;	57	remainder = dir->i_sb->s_blocksize - loffset;
58	memcpy((uint8_t )ad, (bh)->b_data + loffset, remainder);	58	memcpy((uint8_t )ad, (bh)->b_data + loffset, remainder);
59		59
60	udf_release_data(*bh);	60	brelse(*bh);
61	block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);	61	block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
62	if (!block)	62	if (!block)
63	return NULL;	63	return NULL;
Lines 75-83 Link Here
75	udf_fileident_read(struct inode dir, loff_t nf_pos,	75	udf_fileident_read(struct inode dir, loff_t nf_pos,
76	struct udf_fileident_bh *fibh,	76	struct udf_fileident_bh *fibh,
77	struct fileIdentDesc *cfi,	77	struct fileIdentDesc *cfi,
78	kernel_lb_addr bloc, uint32_t extoffset,	78	struct extent_position *epos,
79	kernel_lb_addr eloc, uint32_t elen,	79	kernel_lb_addr eloc, uint32_t elen,
80	uint32_t offset, struct buffer_head *bh)	80	sector_t *offset)
81	{	81	{
82	struct fileIdentDesc *fi;	82	struct fileIdentDesc *fi;
83	int i, num, block;	83	int i, num, block;
Lines 105-117 Link Here
105		105
106	if (fibh->eoffset == dir->i_sb->s_blocksize)	106	if (fibh->eoffset == dir->i_sb->s_blocksize)
107	{	107	{
108	int lextoffset = *extoffset;	108	int lextoffset = epos->offset;
109		109
110	if (udf_next_aext(dir, bloc, extoffset, eloc, elen, bh, 1) !=	110	if (udf_next_aext(dir, epos, eloc, elen, 1) !=
111	(EXT_RECORDED_ALLOCATED >> 30))	111	(EXT_RECORDED_ALLOCATED >> 30))
112	{
113	return NULL;	112	return NULL;
114	}
115		113
116	block = udf_get_lb_pblock(dir->i_sb, eloc, offset);	114	block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
117		115
Lines 120-128 Link Here
120	if ((offset << dir->i_sb->s_blocksize_bits) >= elen)	118	if ((offset << dir->i_sb->s_blocksize_bits) >= elen)
121	*offset = 0;	119	*offset = 0;
122	else	120	else
123	*extoffset = lextoffset;	121	epos->offset = lextoffset;
124		122
125	udf_release_data(fibh->sbh);	123	brelse(fibh->sbh);
126	if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))	124	if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
127	return NULL;	125	return NULL;
128	fibh->soffset = fibh->eoffset = 0;	126	fibh->soffset = fibh->eoffset = 0;
Lines 151-157 Link Here
151	}	149	}
152	else if (fibh->sbh != fibh->ebh)	150	else if (fibh->sbh != fibh->ebh)
153	{	151	{
154	udf_release_data(fibh->sbh);	152	brelse(fibh->sbh);
155	fibh->sbh = fibh->ebh;	153	fibh->sbh = fibh->ebh;
156	}	154	}
157		155
Lines 169-181 Link Here
169	}	167	}
170	else if (fibh->eoffset > dir->i_sb->s_blocksize)	168	else if (fibh->eoffset > dir->i_sb->s_blocksize)
171	{	169	{
172	int lextoffset = *extoffset;	170	int lextoffset = epos->offset;
173		171
174	if (udf_next_aext(dir, bloc, extoffset, eloc, elen, bh, 1) !=	172	if (udf_next_aext(dir, epos, eloc, elen, 1) !=
175	(EXT_RECORDED_ALLOCATED >> 30))	173	(EXT_RECORDED_ALLOCATED >> 30))
176	{
177	return NULL;	174	return NULL;
178	}
179		175
180	block = udf_get_lb_pblock(dir->i_sb, eloc, offset);	176	block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
181		177
Lines 184-190 Link Here
184	if ((offset << dir->i_sb->s_blocksize_bits) >= elen)	180	if ((offset << dir->i_sb->s_blocksize_bits) >= elen)
185	*offset = 0;	181	*offset = 0;
186	else	182	else
187	*extoffset = lextoffset;	183	epos->offset = lextoffset;
188		184
189	fibh->soffset -= dir->i_sb->s_blocksize;	185	fibh->soffset -= dir->i_sb->s_blocksize;
190	fibh->eoffset -= dir->i_sb->s_blocksize;	186	fibh->eoffset -= dir->i_sb->s_blocksize;

Lines 36-41 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/file.c (-7 / +11 lines)
36	#include <linux/smp_lock.h>	36	#include <linux/smp_lock.h>
37	#include <linux/pagemap.h>	37	#include <linux/pagemap.h>
38	#include <linux/buffer_head.h>	38	#include <linux/buffer_head.h>
		39	#include <linux/aio.h>
39		40
40	#include "udf_i.h"	41	#include "udf_i.h"
41	#include "udf_sb.h"	42	#include "udf_sb.h"
Lines 103-112 Link Here
103	.commit_write = udf_adinicb_commit_write,	104	.commit_write = udf_adinicb_commit_write,
104	};	105	};
105		106
106	static ssize_t udf_file_write(struct file * file, const char __user * buf,	107	static ssize_t udf_file_aio_write(struct kiocb iocb, const char __user buf,
107	size_t count, loff_t *ppos)	108	size_t count, loff_t ppos)
108	{	109	{
109	ssize_t retval;	110	ssize_t retval;
		111	struct file *file = iocb->ki_filp;
110	struct inode *inode = file->f_dentry->d_inode;	112	struct inode *inode = file->f_dentry->d_inode;
111	int err, pos;	113	int err, pos;
112		114
Lines 115-121 Link Here
115	if (file->f_flags & O_APPEND)	117	if (file->f_flags & O_APPEND)
116	pos = inode->i_size;	118	pos = inode->i_size;
117	else	119	else
118	pos = *ppos;	120	pos = ppos;
119		121
120	if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +	122	if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
121	pos + count))	123	pos + count))
Lines 136-142 Link Here
136	}	138	}
137	}	139	}
138		140
139	retval = generic_file_write(file, buf, count, ppos);	141	retval = generic_file_aio_write(iocb, buf, count, ppos);
140		142
141	if (retval > 0)	143	if (retval > 0)
142	mark_inode_dirty(inode);	144	mark_inode_dirty(inode);
Lines 249-264 Link Here
249	}	251	}
250		252
251	const struct file_operations udf_file_operations = {	253	const struct file_operations udf_file_operations = {
252	.read = generic_file_read,	254	.read = do_sync_read,
		255	.aio_read = generic_file_aio_read,
253	.ioctl = udf_ioctl,	256	.ioctl = udf_ioctl,
254	.open = generic_file_open,	257	.open = generic_file_open,
255	.mmap = generic_file_mmap,	258	.mmap = generic_file_mmap,
256	.write = udf_file_write,	259	.write = do_sync_write,
		260	.aio_write = udf_file_aio_write,
257	.release = udf_release_file,	261	.release = udf_release_file,
258	.fsync = udf_fsync_file,	262	.fsync = udf_fsync_file,
259	.sendfile = generic_file_sendfile,	263	.sendfile = generic_file_sendfile,
260	};	264	};
261		265
262	struct inode_operations udf_file_inode_operations = {	266	const struct inode_operations udf_file_inode_operations = {
263	.truncate = udf_truncate,	267	.truncate = udf_truncate,
264	};	268	};

Lines 121-127 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/ialloc.c (-5 / +2 lines)
121	UDF_I_LOCATION(inode).logicalBlockNum = block;	121	UDF_I_LOCATION(inode).logicalBlockNum = block;
122	UDF_I_LOCATION(inode).partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;	122	UDF_I_LOCATION(inode).partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
123	inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);	123	inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
124	inode->i_blksize = PAGE_SIZE;
125	inode->i_blocks = 0;	124	inode->i_blocks = 0;
126	UDF_I_LENEATTR(inode) = 0;	125	UDF_I_LENEATTR(inode) = 0;
127	UDF_I_LENALLOC(inode) = 0;	126	UDF_I_LENALLOC(inode) = 0;
Lines 130-143 Link Here
130	{	129	{
131	UDF_I_EFE(inode) = 1;	130	UDF_I_EFE(inode) = 1;
132	UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);	131	UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
133	UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);	132	UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
134	memset(UDF_I_DATA(inode), 0x00, inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
135	}	133	}
136	else	134	else
137	{	135	{
138	UDF_I_EFE(inode) = 0;	136	UDF_I_EFE(inode) = 0;
139	UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);	137	UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
140	memset(UDF_I_DATA(inode), 0x00, inode->i_sb->s_blocksize - sizeof(struct fileEntry));
141	}	138	}
142	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))	139	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))
143	UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;	140	UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;

Lines 274-285 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/misc.c (-6 lines)
274	loc.logicalBlockNum + offset, ident);	274	loc.logicalBlockNum + offset, ident);
275	}	275	}
276		276
277	void udf_release_data(struct buffer_head *bh)
278	{
279	if (bh)
280	brelse(bh);
281	}
282
283	void udf_update_tag(char *data, int length)	277	void udf_update_tag(char *data, int length)
284	{	278	{
285	tag tptr = (tag )data;	279	tag tptr = (tag )data;

Lines 107-118 Link Here

(-)kernel-source-2.6.18.orig/fs/udf/super.c (-52 / +53 lines)
107	.fs_flags = FS_REQUIRES_DEV,	107	.fs_flags = FS_REQUIRES_DEV,
108	};	108	};
109		109
110	static kmem_cache_t * udf_inode_cachep;	110	static struct kmem_cache * udf_inode_cachep;
111		111
112	static struct inode udf_alloc_inode(struct super_block sb)	112	static struct inode udf_alloc_inode(struct super_block sb)
113	{	113	{
114	struct udf_inode_info *ei;	114	struct udf_inode_info *ei;
115	ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, SLAB_KERNEL);	115	ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
116	if (!ei)	116	if (!ei)
117	return NULL;	117	return NULL;
118		118
Lines 130-145 Link Here
130	kmem_cache_free(udf_inode_cachep, UDF_I(inode));	130	kmem_cache_free(udf_inode_cachep, UDF_I(inode));
131	}	131	}
132		132
133	static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)	133	static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
134	{	134	{
135	struct udf_inode_info ei = (struct udf_inode_info ) foo;	135	struct udf_inode_info ei = (struct udf_inode_info ) foo;
136		136
137	if ((flags & (SLAB_CTOR_VERIFY\|SLAB_CTOR_CONSTRUCTOR)) ==	137	ei->i_ext.i_data = NULL;
138	SLAB_CTOR_CONSTRUCTOR)	138	inode_init_once(&ei->vfs_inode);
139	{
140	ei->i_ext.i_data = NULL;
141	inode_init_once(&ei->vfs_inode);
142	}
143	}	139	}
144		140
145	static int init_inodecache(void)	141	static int init_inodecache(void)
Lines 156-167 Link Here
156		152
157	static void destroy_inodecache(void)	153	static void destroy_inodecache(void)
158	{	154	{
159	if (kmem_cache_destroy(udf_inode_cachep))	155	kmem_cache_destroy(udf_inode_cachep);
160	printk(KERN_INFO "udf_inode_cache: not all structures were freed\n");
161	}	156	}
162		157
163	/* Superblock operations */	158	/* Superblock operations */
164	static struct super_operations udf_sb_ops = {	159	static const struct super_operations udf_sb_ops = {
165	.alloc_inode = udf_alloc_inode,	160	.alloc_inode = udf_alloc_inode,
166	.destroy_inode = udf_destroy_inode,	161	.destroy_inode = udf_destroy_inode,
167	.write_inode = udf_write_inode,	162	.write_inode = udf_write_inode,
Lines 566-572 Link Here
566		561
567	if (vsd->stdIdent[0] == 0)	562	if (vsd->stdIdent[0] == 0)
568	{	563	{
569	udf_release_data(bh);	564	brelse(bh);
570	break;	565	break;
571	}	566	}
572	else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN))	567	else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN))
Lines 599-605 Link Here
599	}	594	}
600	else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN))	595	else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN))
601	{	596	{
602	udf_release_data(bh);	597	brelse(bh);
603	break;	598	break;
604	}	599	}
605	else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN))	600	else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN))
Lines 610-616 Link Here
610	{	605	{
611	nsr03 = sector;	606	nsr03 = sector;
612	}	607	}
613	udf_release_data(bh);	608	brelse(bh);
614	}	609	}
615		610
616	if (nsr03)	611	if (nsr03)
Lines 676-682 Link Here
676	{	671	{
677	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);	672	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
678	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);	673	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
679	udf_release_data(bh);	674	brelse(bh);
680	}	675	}
681		676
682	if (ident == TAG_IDENT_AVDP)	677	if (ident == TAG_IDENT_AVDP)
Lines 711-717 Link Here
711	{	706	{
712	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);	707	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
713	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);	708	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
714	udf_release_data(bh);	709	brelse(bh);
715	}	710	}
716		711
717	if (ident == TAG_IDENT_AVDP &&	712	if (ident == TAG_IDENT_AVDP &&
Lines 730-736 Link Here
730	{	725	{
731	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);	726	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
732	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);	727	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
733	udf_release_data(bh);	728	brelse(bh);
734	}	729	}
735		730
736	if (ident == TAG_IDENT_AVDP &&	731	if (ident == TAG_IDENT_AVDP &&
Lines 752-758 Link Here
752	{	747	{
753	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);	748	ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
754	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);	749	location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
755	udf_release_data(bh);	750	brelse(bh);
756		751
757	if (ident == TAG_IDENT_AVDP && location == 256)	752	if (ident == TAG_IDENT_AVDP && location == 256)
758	UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);	753	UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
Lines 769-775 Link Here
769	}	764	}
770	else	765	else
771	{	766	{
772	udf_release_data(bh);	767	brelse(bh);
773	if ((ident != TAG_IDENT_AVDP) && (i \|\|	768	if ((ident != TAG_IDENT_AVDP) && (i \|\|
774	(ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))	769	(ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))
775	{	770	{
Lines 798-804 Link Here
798	return 1;	793	return 1;
799	else if (ident != TAG_IDENT_FSD)	794	else if (ident != TAG_IDENT_FSD)
800	{	795	{
801	udf_release_data(bh);	796	brelse(bh);
802	return 1;	797	return 1;
803	}	798	}
804		799
Lines 837-843 Link Here
837	newfileset.logicalBlockNum += 1 +	832	newfileset.logicalBlockNum += 1 +
838	((le32_to_cpu(sp->numOfBytes) + sizeof(struct spaceBitmapDesc) - 1)	833	((le32_to_cpu(sp->numOfBytes) + sizeof(struct spaceBitmapDesc) - 1)
839	>> sb->s_blocksize_bits);	834	>> sb->s_blocksize_bits);
840	udf_release_data(bh);	835	brelse(bh);
841	break;	836	break;
842	}	837	}
843	case TAG_IDENT_FSD:	838	case TAG_IDENT_FSD:
Lines 848-854 Link Here
848	default:	843	default:
849	{	844	{
850	newfileset.logicalBlockNum ++;	845	newfileset.logicalBlockNum ++;
851	udf_release_data(bh);	846	brelse(bh);
852	bh = NULL;	847	bh = NULL;
853	break;	848	break;
854	}	849	}
Lines 868-874 Link Here
868		863
869	UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;	864	UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
870	udf_load_fileset(sb, bh, root);	865	udf_load_fileset(sb, bh, root);
871	udf_release_data(bh);	866	brelse(bh);
872	return 0;	867	return 0;
873	}	868	}
874	return 1;	869	return 1;
Lines 1086-1092 Link Here
1086	if (ident != 0 \|\|	1081	if (ident != 0 \|\|
1087	strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING)))	1082	strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING)))
1088	{	1083	{
1089	udf_release_data(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);	1084	brelse(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
1090	UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;	1085	UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;
1091	}	1086	}
1092	}	1087	}
Lines 1140-1151 Link Here
1140	udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));	1135	udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
1141		1136
1142	if (UDF_SB_LVIDBH(sb) != bh)	1137	if (UDF_SB_LVIDBH(sb) != bh)
1143	udf_release_data(bh);	1138	brelse(bh);
1144	loc.extLength -= sb->s_blocksize;	1139	loc.extLength -= sb->s_blocksize;
1145	loc.extLocation ++;	1140	loc.extLocation ++;
1146	}	1141	}
1147	if (UDF_SB_LVIDBH(sb) != bh)	1142	if (UDF_SB_LVIDBH(sb) != bh)
1148	udf_release_data(bh);	1143	brelse(bh);
1149	}	1144	}
1150		1145
1151	/*	1146	/*
Lines 1248-1254 Link Here
1248	done = 1;	1243	done = 1;
1249	break;	1244	break;
1250	}	1245	}
1251	udf_release_data(bh);	1246	brelse(bh);
1252	}	1247	}
1253	for (i=0; i<VDS_POS_LENGTH; i++)	1248	for (i=0; i<VDS_POS_LENGTH; i++)
1254	{	1249	{
Lines 1270-1279 Link Here
1270	gd = (struct generic_desc *)bh2->b_data;	1265	gd = (struct generic_desc *)bh2->b_data;
1271	if (ident == TAG_IDENT_PD)	1266	if (ident == TAG_IDENT_PD)
1272	udf_load_partdesc(sb, bh2);	1267	udf_load_partdesc(sb, bh2);
1273	udf_release_data(bh2);	1268	brelse(bh2);
1274	}	1269	}
1275	}	1270	}
1276	udf_release_data(bh);	1271	brelse(bh);
1277	}	1272	}
1278	}	1273	}
1279		1274
Lines 1336-1342 Link Here
1336	reserve_e = reserve_e >> sb->s_blocksize_bits;	1331	reserve_e = reserve_e >> sb->s_blocksize_bits;
1337	reserve_e += reserve_s;	1332	reserve_e += reserve_s;
1338		1333
1339	udf_release_data(bh);	1334	brelse(bh);
1340		1335
1341	/* Process the main & reserve sequences */	1336	/* Process the main & reserve sequences */
1342	/* responsible for finding the PartitionDesc(s) */	1337	/* responsible for finding the PartitionDesc(s) */
Lines 1356-1362 Link Here
1356		1351
1357	for (i=0; i<UDF_SB_NUMPARTS(sb); i++)	1352	for (i=0; i<UDF_SB_NUMPARTS(sb); i++)
1358	{	1353	{
1359	switch UDF_SB_PARTTYPE(sb, i)	1354	switch (UDF_SB_PARTTYPE(sb, i))
1360	{	1355	{
1361	case UDF_VIRTUAL_MAP15:	1356	case UDF_VIRTUAL_MAP15:
1362	case UDF_VIRTUAL_MAP20:	1357	case UDF_VIRTUAL_MAP20:
Lines 1406-1417 Link Here
1406		1401
1407	pos = udf_block_map(UDF_SB_VAT(sb), 0);	1402	pos = udf_block_map(UDF_SB_VAT(sb), 0);
1408	bh = sb_bread(sb, pos);	1403	bh = sb_bread(sb, pos);
		1404	if (!bh)
		1405	return 1;
1409	UDF_SB_TYPEVIRT(sb,i).s_start_offset =	1406	UDF_SB_TYPEVIRT(sb,i).s_start_offset =
1410	le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data + udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +	1407	le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data + udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +
1411	udf_ext0_offset(UDF_SB_VAT(sb));	1408	udf_ext0_offset(UDF_SB_VAT(sb));
1412	UDF_SB_TYPEVIRT(sb,i).s_num_entries = (UDF_SB_VAT(sb)->i_size -	1409	UDF_SB_TYPEVIRT(sb,i).s_num_entries = (UDF_SB_VAT(sb)->i_size -
1413	UDF_SB_TYPEVIRT(sb,i).s_start_offset) >> 2;	1410	UDF_SB_TYPEVIRT(sb,i).s_start_offset) >> 2;
1414	udf_release_data(bh);	1411	brelse(bh);
1415	}	1412	}
1416	UDF_SB_PARTROOT(sb,i) = udf_get_pblock(sb, 0, i, 0);	1413	UDF_SB_PARTROOT(sb,i) = udf_get_pblock(sb, 0, i, 0);
1417	UDF_SB_PARTLEN(sb,i) = UDF_SB_PARTLEN(sb,ino.partitionReferenceNum);	1414	UDF_SB_PARTLEN(sb,i) = UDF_SB_PARTLEN(sb,ino.partitionReferenceNum);
Lines 1622-1627 Link Here
1622	goto error_out;	1619	goto error_out;
1623	}	1620	}
1624		1621
		1622	if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) {
		1623	printk("UDF-fs: Partition marked readonly; forcing readonly mount\n");
		1624	sb->s_flags \|= MS_RDONLY;
		1625	}
		1626
1625	if ( udf_find_fileset(sb, &fileset, &rootdir) )	1627	if ( udf_find_fileset(sb, &fileset, &rootdir) )
1626	{	1628	{
1627	printk("UDF-fs: No fileset found\n");	1629	printk("UDF-fs: No fileset found\n");
Lines 1659-1665 Link Here
1659	iput(inode);	1661	iput(inode);
1660	goto error_out;	1662	goto error_out;
1661	}	1663	}
1662	sb->s_maxbytes = 1<<30;	1664	sb->s_maxbytes = MAX_LFS_FILESIZE;
1663	return 0;	1665	return 0;
1664		1666
1665	error_out:	1667	error_out:
Lines 1678-1684 Link Here
1678	if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)	1680	if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
1679	{	1681	{
1680	for (i=0; i<4; i++)	1682	for (i=0; i<4; i++)
1681	udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);	1683	brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
1682	}	1684	}
1683	}	1685	}
1684	#ifdef CONFIG_UDF_NLS	1686	#ifdef CONFIG_UDF_NLS
Lines 1687-1693 Link Here
1687	#endif	1689	#endif
1688	if (!(sb->s_flags & MS_RDONLY))	1690	if (!(sb->s_flags & MS_RDONLY))
1689	udf_close_lvid(sb);	1691	udf_close_lvid(sb);
1690	udf_release_data(UDF_SB_LVIDBH(sb));	1692	brelse(UDF_SB_LVIDBH(sb));
1691	UDF_SB_FREE(sb);	1693	UDF_SB_FREE(sb);
1692	kfree(sbi);	1694	kfree(sbi);
1693	sb->s_fs_info = NULL;	1695	sb->s_fs_info = NULL;
Lines 1705-1711 Link Here
1705	sb->s_dirt = 1;	1707	sb->s_dirt = 1;
1706	}	1708	}
1707	va_start(args, fmt);	1709	va_start(args, fmt);
1708	vsprintf(error_buf, fmt, args);	1710	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
1709	va_end(args);	1711	va_end(args);
1710	printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",	1712	printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
1711	sb->s_id, function, error_buf);	1713	sb->s_id, function, error_buf);
Lines 1717-1723 Link Here
1717	va_list args;	1719	va_list args;
1718		1720
1719	va_start (args, fmt);	1721	va_start (args, fmt);
1720	vsprintf(error_buf, fmt, args);	1722	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
1721	va_end(args);	1723	va_end(args);
1722	printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",	1724	printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
1723	sb->s_id, function, error_buf);	1725	sb->s_id, function, error_buf);
Lines 1756-1762 Link Here
1756	if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)	1758	if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
1757	{	1759	{
1758	for (i=0; i<4; i++)	1760	for (i=0; i<4; i++)
1759	udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);	1761	brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
1760	}	1762	}
1761	}	1763	}
1762	#ifdef CONFIG_UDF_NLS	1764	#ifdef CONFIG_UDF_NLS
Lines 1765-1771 Link Here
1765	#endif	1767	#endif
1766	if (!(sb->s_flags & MS_RDONLY))	1768	if (!(sb->s_flags & MS_RDONLY))
1767	udf_close_lvid(sb);	1769	udf_close_lvid(sb);
1768	udf_release_data(UDF_SB_LVIDBH(sb));	1770	brelse(UDF_SB_LVIDBH(sb));
1769	UDF_SB_FREE(sb);	1771	UDF_SB_FREE(sb);
1770	kfree(sb->s_fs_info);	1772	kfree(sb->s_fs_info);
1771	sb->s_fs_info = NULL;	1773	sb->s_fs_info = NULL;
Lines 1835-1841 Link Here
1835	}	1837	}
1836	else if (ident != TAG_IDENT_SBD)	1838	else if (ident != TAG_IDENT_SBD)
1837	{	1839	{
1838	udf_release_data(bh);	1840	brelse(bh);
1839	printk(KERN_ERR "udf: udf_count_free failed\n");	1841	printk(KERN_ERR "udf: udf_count_free failed\n");
1840	goto out;	1842	goto out;
1841	}	1843	}
Lines 1857-1863 Link Here
1857	}	1859	}
1858	if ( bytes )	1860	if ( bytes )
1859	{	1861	{
1860	udf_release_data(bh);	1862	brelse(bh);
1861	newblock = udf_get_lb_pblock(sb, loc, ++block);	1863	newblock = udf_get_lb_pblock(sb, loc, ++block);
1862	bh = udf_tread(sb, newblock);	1864	bh = udf_tread(sb, newblock);
1863	if (!bh)	1865	if (!bh)
Lines 1869-1875 Link Here
1869	ptr = (uint8_t *)bh->b_data;	1871	ptr = (uint8_t *)bh->b_data;
1870	}	1872	}
1871	}	1873	}
1872	udf_release_data(bh);	1874	brelse(bh);
1873		1875
1874	out:	1876	out:
1875	unlock_kernel();	1877	unlock_kernel();
Lines 1881-1901 Link Here
1881	udf_count_free_table(struct super_block sb, struct inode table)	1883	udf_count_free_table(struct super_block sb, struct inode table)
1882	{	1884	{
1883	unsigned int accum = 0;	1885	unsigned int accum = 0;
1884	uint32_t extoffset, elen;	1886	uint32_t elen;
1885	kernel_lb_addr bloc, eloc;	1887	kernel_lb_addr eloc;
1886	int8_t etype;	1888	int8_t etype;
1887	struct buffer_head *bh = NULL;	1889	struct extent_position epos;
1888		1890
1889	lock_kernel();	1891	lock_kernel();
1890		1892
1891	bloc = UDF_I_LOCATION(table);	1893	epos.block = UDF_I_LOCATION(table);
1892	extoffset = sizeof(struct unallocSpaceEntry);	1894	epos.offset = sizeof(struct unallocSpaceEntry);
		1895	epos.bh = NULL;
1893		1896
1894	while ((etype = udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)	1897	while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
1895	{
1896	accum += (elen >> table->i_sb->s_blocksize_bits);	1898	accum += (elen >> table->i_sb->s_blocksize_bits);
1897	}	1899	brelse(epos.bh);
1898	udf_release_data(bh);
1899		1900
1900	unlock_kernel();	1901	unlock_kernel();
1901		1902