Attachment #330750 for bug #133718

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

Lines 196-201 static int udf_release_file(struct inode inode, struct file filp) Link Here

(-)a/fs/udf/file.c (+1 lines)
196	mutex_lock(&inode->i_mutex);	196	mutex_lock(&inode->i_mutex);
197	lock_kernel();	197	lock_kernel();
198	udf_discard_prealloc(inode);	198	udf_discard_prealloc(inode);
		199	udf_truncate_tail_extent(inode);
199	unlock_kernel();	200	unlock_kernel();
200	mutex_unlock(&inode->i_mutex);	201	mutex_unlock(&inode->i_mutex);
201	}	202	}




 */
void udf_clear_inode(struct inode *inode)
{
	struct udf_inode_info *iinfo = UDF_I(inode);

	if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB &&
	    inode->i_size != iinfo->i_lenExtents) {
		printk(KERN_WARNING "UDF-fs (%s): Inode %lu (mode %o) has "
			"inode size %llu different from extent lenght %llu. "
			"Filesystem need not be standards compliant.\n",
			inode->i_sb->s_id, inode->i_ino, inode->i_mode,
			(unsigned long long)inode->i_size,
			(unsigned long long)iinfo->i_lenExtents);
	}
	iinfo = UDF_I(inode);
	kfree(iinfo->i_ext.i_data);
	iinfo->i_ext.i_data = NULL;
}

	int newblock;
	struct buffer_head *dbh = NULL;
	struct kernel_lb_addr eloc;
	uint32_t elen;
	uint8_t alloctype;
	struct extent_position epos;


	eloc.logicalBlockNum = *block;
	eloc.partitionReferenceNum =
				iinfo->i_location.partitionReferenceNum;
	iinfo->i_lenExtents = inode->i_size;
	iinfo->i_lenExtents = elen;
	epos.bh = NULL;
	epos.block = iinfo->i_location;
	epos.offset = udf_file_entry_alloc_offset(inode);
	udf_add_aext(inode, &epos, &eloc, inode->i_size, 0);
	/* UniqueID stuff */

	brelse(epos.bh);




	}

add:
	/* Is there any extent whose size we need to round up? */
	if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB && elen) {
		elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
		if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
			epos.offset -= sizeof(struct short_ad);
		else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
			epos.offset -= sizeof(struct long_ad);
		udf_write_aext(dir, &epos, &eloc, elen, 1);
	}
	f_pos += nfidlen;

	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&

		udf_current_aext(dir, &epos, &eloc, &elen, 1);
	}

	/* Entry fits into current block? */
	if (sb->s_blocksize - fibh->eoffset >= nfidlen) {
		fibh->soffset = fibh->eoffset;
		fibh->eoffset += nfidlen;

				(fibh->sbh->b_data + fibh->soffset);
		}
	} else {
		/* Round up last extent in the file */
		elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
		if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
			epos.offset -= sizeof(struct short_ad);
		else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
			epos.offset -= sizeof(struct long_ad);
		udf_write_aext(dir, &epos, &eloc, elen, 1);
		dinfo->i_lenExtents = (dinfo->i_lenExtents + sb->s_blocksize
					- 1) & ~(sb->s_blocksize - 1);

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

		dir->i_size += nfidlen;
		if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
			dinfo->i_lenAlloc += nfidlen;
		else {
			/* Find the last extent and truncate it to proper size */
			while (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
                	            (EXT_RECORDED_ALLOCATED >> 30));
			elen -= dinfo->i_lenExtents - dir->i_size;
			if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
				epos.offset -= sizeof(struct short_ad);
			else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
				epos.offset -= sizeof(struct long_ad);
			udf_write_aext(dir, &epos, &eloc, elen, 1);
			dinfo->i_lenExtents = dir->i_size;
		}
		
		mark_inode_dirty(dir);
		goto out_ok;
	} else {

		block = udf_get_pblock(inode->i_sb, block,
				iinfo->i_location.partitionReferenceNum,
				0);
		epos.bh = udf_tgetblk(inode->i_sb, block);
		lock_buffer(epos.bh);
		memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
		set_buffer_uptodate(epos.bh);

	inode->i_size = elen;
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
		iinfo->i_lenAlloc = inode->i_size;
	else
		udf_truncate_tail_extent(inode);
	mark_inode_dirty(inode);

	fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
- 

Return to bug 133718

Lines 408-422 static struct fileIdentDesc udf_add_entry(struct inode dir, Link Here

(-)a/fs/udf/namei.c (-11 / +27 lines)
408	}	408	}
409		409
410	add:	410	add:
411	/* Is there any extent whose size we need to round up? */
412	if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB && elen) {
413	elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
414	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
415	epos.offset -= sizeof(struct short_ad);
416	else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
417	epos.offset -= sizeof(struct long_ad);
418	udf_write_aext(dir, &epos, &eloc, elen, 1);
419	}
420	f_pos += nfidlen;	411	f_pos += nfidlen;
421		412
422	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&	413	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
Lines 439-444 add: Link Here
439	udf_current_aext(dir, &epos, &eloc, &elen, 1);	430	udf_current_aext(dir, &epos, &eloc, &elen, 1);
440	}	431	}
441		432
		433	/* Entry fits into current block? */
442	if (sb->s_blocksize - fibh->eoffset >= nfidlen) {	434	if (sb->s_blocksize - fibh->eoffset >= nfidlen) {
443	fibh->soffset = fibh->eoffset;	435	fibh->soffset = fibh->eoffset;
444	fibh->eoffset += nfidlen;	436	fibh->eoffset += nfidlen;
Lines 462-467 add: Link Here
462	(fibh->sbh->b_data + fibh->soffset);	454	(fibh->sbh->b_data + fibh->soffset);
463	}	455	}
464	} else {	456	} else {
		457	/* Round up last extent in the file */
		458	elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
		459	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		460	epos.offset -= sizeof(struct short_ad);
		461	else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
		462	epos.offset -= sizeof(struct long_ad);
		463	udf_write_aext(dir, &epos, &eloc, elen, 1);
		464	dinfo->i_lenExtents = (dinfo->i_lenExtents + sb->s_blocksize
		465	- 1) & ~(sb->s_blocksize - 1);
		466
465	fibh->soffset = fibh->eoffset - sb->s_blocksize;	467	fibh->soffset = fibh->eoffset - sb->s_blocksize;
466	fibh->eoffset += nfidlen - sb->s_blocksize;	468	fibh->eoffset += nfidlen - sb->s_blocksize;
467	if (fibh->sbh != fibh->ebh) {	469	if (fibh->sbh != fibh->ebh) {
Lines 508-513 add: Link Here
508	dir->i_size += nfidlen;	510	dir->i_size += nfidlen;
509	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)	511	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
510	dinfo->i_lenAlloc += nfidlen;	512	dinfo->i_lenAlloc += nfidlen;
		513	else {
		514	/* Find the last extent and truncate it to proper size */
		515	while (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
		516	(EXT_RECORDED_ALLOCATED >> 30));
		517	elen -= dinfo->i_lenExtents - dir->i_size;
		518	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		519	epos.offset -= sizeof(struct short_ad);
		520	else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
		521	epos.offset -= sizeof(struct long_ad);
		522	udf_write_aext(dir, &epos, &eloc, elen, 1);
		523	dinfo->i_lenExtents = dir->i_size;
		524	}
		525
511	mark_inode_dirty(dir);	526	mark_inode_dirty(dir);
512	goto out_ok;	527	goto out_ok;
513	} else {	528	} else {
Lines 922-928 static int udf_symlink(struct inode dir, struct dentry dentry, Link Here
922	block = udf_get_pblock(inode->i_sb, block,	937	block = udf_get_pblock(inode->i_sb, block,
923	iinfo->i_location.partitionReferenceNum,	938	iinfo->i_location.partitionReferenceNum,
924	0);	939	0);
925	epos.bh = udf_tread(inode->i_sb, block);	940	epos.bh = udf_tgetblk(inode->i_sb, block);
926	lock_buffer(epos.bh);	941	lock_buffer(epos.bh);
927	memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);	942	memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
928	set_buffer_uptodate(epos.bh);	943	set_buffer_uptodate(epos.bh);
Lines 999-1004 static int udf_symlink(struct inode dir, struct dentry dentry, Link Here
999	inode->i_size = elen;	1014	inode->i_size = elen;
1000	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)	1015	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
1001	iinfo->i_lenAlloc = inode->i_size;	1016	iinfo->i_lenAlloc = inode->i_size;
		1017	else
		1018	udf_truncate_tail_extent(inode);
1002	mark_inode_dirty(inode);	1019	mark_inode_dirty(inode);
1003		1020
1004	fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);	1021	fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
1005	-

Lines 97-111 no_delete: Link Here

(-)a/fs/udf/inode.c (-12 / +12 lines)
97	*/	97	*/
98	void udf_clear_inode(struct inode *inode)	98	void udf_clear_inode(struct inode *inode)
99	{	99	{
100	struct udf_inode_info *iinfo;	100	struct udf_inode_info *iinfo = UDF_I(inode);
101	if (!(inode->i_sb->s_flags & MS_RDONLY)) {	101
102	lock_kernel();	102	if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB &&
103	udf_truncate_tail_extent(inode);	103	inode->i_size != iinfo->i_lenExtents) {
104	unlock_kernel();	104	printk(KERN_WARNING "UDF-fs (%s): Inode %lu (mode %o) has "
105	write_inode_now(inode, 0);	105	"inode size %llu different from extent lenght %llu. "
106	invalidate_inode_buffers(inode);	106	"Filesystem need not be standards compliant.\n",
		107	inode->i_sb->s_id, inode->i_ino, inode->i_mode,
		108	(unsigned long long)inode->i_size,
		109	(unsigned long long)iinfo->i_lenExtents);
107	}	110	}
108	iinfo = UDF_I(inode);
109	kfree(iinfo->i_ext.i_data);	111	kfree(iinfo->i_ext.i_data);
110	iinfo->i_ext.i_data = NULL;	112	iinfo->i_ext.i_data = NULL;
111	}	113	}
Lines 198-204 struct buffer_head udf_expand_dir_adinicb(struct inode inode, int *block, Link Here
198	int newblock;	200	int newblock;
199	struct buffer_head *dbh = NULL;	201	struct buffer_head *dbh = NULL;
200	struct kernel_lb_addr eloc;	202	struct kernel_lb_addr eloc;
201	uint32_t elen;
202	uint8_t alloctype;	203	uint8_t alloctype;
203	struct extent_position epos;	204	struct extent_position epos;
204		205
Lines 273-284 struct buffer_head udf_expand_dir_adinicb(struct inode inode, int *block, Link Here
273	eloc.logicalBlockNum = *block;	274	eloc.logicalBlockNum = *block;
274	eloc.partitionReferenceNum =	275	eloc.partitionReferenceNum =
275	iinfo->i_location.partitionReferenceNum;	276	iinfo->i_location.partitionReferenceNum;
276	elen = inode->i_sb->s_blocksize;	277	iinfo->i_lenExtents = inode->i_size;
277	iinfo->i_lenExtents = elen;
278	epos.bh = NULL;	278	epos.bh = NULL;
279	epos.block = iinfo->i_location;	279	epos.block = iinfo->i_location;
280	epos.offset = udf_file_entry_alloc_offset(inode);	280	epos.offset = udf_file_entry_alloc_offset(inode);
281	udf_add_aext(inode, &epos, &eloc, elen, 0);	281	udf_add_aext(inode, &epos, &eloc, inode->i_size, 0);
282	/* UniqueID stuff */	282	/* UniqueID stuff */
283		283
284	brelse(epos.bh);	284	brelse(epos.bh);