/*
   * namei.c
   *
   * PURPOSE
   *      Inode name handling routines for the OSTA-UDF(tm) filesystem.
   *

   * COPYRIGHT
   *      This file is distributed under the terms of the GNU General Public
   *      License (GPL). Copies of the GPL can be obtained from:
   *              ftp://prep.ai.mit.edu/pub/gnu/GPL
   *      Each contributing author retains all rights to their own work.
   *
   *  (C) 1998-2004 Ben Fennema
   *  (C) 1999-2000 Stelias Computing Inc
   *
   * HISTORY
   *
   *  12/12/98 blf  Created. Split out the lookup code from dir.c
   *  04/19/99 blf  link, mknod, symlink support
   */
  
  #include "udfdecl.h"
  
  #include "udf_i.h"
  #include "udf_sb.h"
  #include <linux/string.h>
  #include <linux/errno.h>
  #include <linux/mm.h>
  #include <linux/slab.h>

  #include <linux/buffer_head.h>

  #include <linux/sched.h>

  #include <linux/crc-itu-t.h>

  #include <linux/exportfs.h>

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

  {
  	if (len1 != len2)
  		return 0;

  	return !memcmp(name1, name2, len1);
  }
  
  int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,

  		 struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh,

  		 uint8_t *impuse, uint8_t *fileident)

  {

  	uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(struct tag);

  	uint16_t crc;

  	int offset;
  	uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
  	uint8_t lfi = cfi->lengthFileIdent;
  	int padlen = fibh->eoffset - fibh->soffset - liu - lfi -

  		sizeof(struct fileIdentDesc);

  	int adinicb = 0;

  	if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  		adinicb = 1;
  
  	offset = fibh->soffset + sizeof(struct fileIdentDesc);

  	if (impuse) {

  		if (adinicb || (offset + liu < 0)) {
  			memcpy((uint8_t *)sfi->impUse, impuse, liu);
  		} else if (offset >= 0) {

  			memcpy(fibh->ebh->b_data + offset, impuse, liu);

  		} else {
  			memcpy((uint8_t *)sfi->impUse, impuse, -offset);

  			memcpy(fibh->ebh->b_data, impuse - offset,
  				liu + offset);

  		}
  	}
  
  	offset += liu;

  	if (fileident) {

  		if (adinicb || (offset + lfi < 0)) {
  			memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi);
  		} else if (offset >= 0) {

  			memcpy(fibh->ebh->b_data + offset, fileident, lfi);

  		} else {

  			memcpy((uint8_t *)sfi->fileIdent + liu, fileident,
  				-offset);
  			memcpy(fibh->ebh->b_data, fileident - offset,
  				lfi + offset);

  		}
  	}
  
  	offset += lfi;

  	if (adinicb || (offset + padlen < 0)) {
  		memset((uint8_t *)sfi->padding + liu + lfi, 0x00, padlen);
  	} else if (offset >= 0) {

  		memset(fibh->ebh->b_data + offset, 0x00, padlen);

  	} else {
  		memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset);

  		memset(fibh->ebh->b_data, 0x00, padlen + offset);
  	}

  	crc = crc_itu_t(0, (uint8_t *)cfi + sizeof(struct tag),
  		      sizeof(struct fileIdentDesc) - sizeof(struct tag));

  
  	if (fibh->sbh == fibh->ebh) {

  		crc = crc_itu_t(crc, (uint8_t *)sfi->impUse,

  			      crclen + sizeof(struct tag) -

  			      sizeof(struct fileIdentDesc));

  	} else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) {

  		crc = crc_itu_t(crc, fibh->ebh->b_data +

  					sizeof(struct fileIdentDesc) +
  					fibh->soffset,

  			      crclen + sizeof(struct tag) -

  					sizeof(struct fileIdentDesc));

  	} else {

  		crc = crc_itu_t(crc, (uint8_t *)sfi->impUse,
  			      -fibh->soffset - sizeof(struct fileIdentDesc));
  		crc = crc_itu_t(crc, fibh->ebh->b_data, fibh->eoffset);

  	}
  
  	cfi->descTag.descCRC = cpu_to_le16(crc);
  	cfi->descTag.descCRCLength = cpu_to_le16(crclen);

  	cfi->descTag.tagChecksum = udf_tag_checksum(&cfi->descTag);

  	if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) {

  		memcpy((uint8_t *)sfi, (uint8_t *)cfi,
  			sizeof(struct fileIdentDesc));

  	} else {
  		memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset);
  		memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset,

  		       sizeof(struct fileIdentDesc) + fibh->soffset);

  	}

  	if (adinicb) {

  		mark_inode_dirty(inode);

  	} else {

  		if (fibh->sbh != fibh->ebh)
  			mark_buffer_dirty_inode(fibh->ebh, inode);
  		mark_buffer_dirty_inode(fibh->sbh, inode);
  	}
  	return 0;
  }

  static struct fileIdentDesc *udf_find_entry(struct inode *dir,

  					    const struct qstr *child,

  					    struct udf_fileident_bh *fibh,
  					    struct fileIdentDesc *cfi)

  {

  	struct fileIdentDesc *fi = NULL;

  	loff_t f_pos;
  	int block, flen;

  	unsigned char *fname = NULL;
  	unsigned char *nameptr;

  	uint8_t lfi;
  	uint16_t liu;

  	loff_t size;

  	struct kernel_lb_addr eloc;

  	uint32_t elen;

  	sector_t offset;

  	struct extent_position epos = {};

  	struct udf_inode_info *dinfo = UDF_I(dir);

  	int isdotdot = child->len == 2 &&
  		child->name[0] == '.' && child->name[1] == '.';

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

  	fibh->sbh = fibh->ebh = NULL;

  	fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1);

  	if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
  		if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos,
  		    &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30))
  			goto out_err;

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

  		if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {

  			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);

  		} else

  			offset = 0;

  		fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);

  		if (!fibh->sbh)
  			goto out_err;

  	}

  	fname = kmalloc(UDF_NAME_LEN, GFP_NOFS);
  	if (!fname)
  		goto out_err;

  	while (f_pos < size) {

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

  		if (!fi)
  			goto out_err;

  
  		liu = le16_to_cpu(cfi->lengthOfImpUse);
  		lfi = cfi->lengthFileIdent;

  		if (fibh->sbh == fibh->ebh) {

  			nameptr = fi->fileIdent + liu;

  		} else {

  			int poffset;	/* Unpaded ending offset */

  			poffset = fibh->soffset + sizeof(struct fileIdentDesc) +
  					liu + lfi;

  			if (poffset >= lfi)
  				nameptr = (uint8_t *)(fibh->ebh->b_data +
  						      poffset - lfi);
  			else {

  				nameptr = fname;

  				memcpy(nameptr, fi->fileIdent + liu,
  					lfi - poffset);
  				memcpy(nameptr + lfi - poffset,
  					fibh->ebh->b_data, poffset);

  			}
  		}

  		if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
  			if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNDELETE))

  				continue;
  		}

  
  		if ((cfi->fileCharacteristics & FID_FILE_CHAR_HIDDEN) != 0) {
  			if (!UDF_QUERY_FLAG(dir->i_sb, UDF_FLAG_UNHIDE))

  				continue;
  		}

  		if ((cfi->fileCharacteristics & FID_FILE_CHAR_PARENT) &&

  		    isdotdot)
  			goto out_ok;

  		if (!lfi)
  			continue;

  		flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi);

  		if (flen && udf_match(flen, fname, child->len, child->name))

  			goto out_ok;

  	}

  out_err:
  	fi = NULL;

  	if (fibh->sbh != fibh->ebh)

  		brelse(fibh->ebh);
  	brelse(fibh->sbh);

  out_ok:

  	brelse(epos.bh);

  	kfree(fname);

  	return fi;

  }

  static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,

  				 unsigned int flags)

  {
  	struct inode *inode = NULL;

  	struct fileIdentDesc cfi;

  	struct udf_fileident_bh fibh;

  	if (dentry->d_name.len > UDF_NAME_LEN - 2)

  		return ERR_PTR(-ENAMETOOLONG);

  #ifdef UDF_RECOVERY
  	/* temporary shorthand for specifying files by inode number */

  	if (!strncmp(dentry->d_name.name, ".B=", 3)) {

  		struct kernel_lb_addr lb = {

  			.logicalBlockNum = 0,

  			.partitionReferenceNum =
  				simple_strtoul(dentry->d_name.name + 3,
  						NULL, 0),

  		};

  		inode = udf_iget(dir->i_sb, lb);

  		if (!inode) {

  			return ERR_PTR(-EACCES);
  		}

  	} else

  #endif /* UDF_RECOVERY */

  	if (udf_find_entry(dir, &dentry->d_name, &fibh, &cfi)) {

  		struct kernel_lb_addr loc;

  		if (fibh.sbh != fibh.ebh)

  			brelse(fibh.ebh);
  		brelse(fibh.sbh);

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

  		if (!inode) {

  			return ERR_PTR(-EACCES);
  		}
  	}

  	return d_splice_alias(inode, dentry);

  }

  static struct fileIdentDesc *udf_add_entry(struct inode *dir,
  					   struct dentry *dentry,
  					   struct udf_fileident_bh *fibh,
  					   struct fileIdentDesc *cfi, int *err)

  {

  	struct super_block *sb = dir->i_sb;

  	struct fileIdentDesc *fi = NULL;

  	unsigned char *name = NULL;

  	int namelen;
  	loff_t f_pos;

  	loff_t size = udf_ext0_offset(dir) + dir->i_size;

  	int nfidlen;
  	uint8_t lfi;
  	uint16_t liu;
  	int block;

  	struct kernel_lb_addr eloc;

  	uint32_t elen = 0;

  	sector_t offset;

  	struct extent_position epos = {};

  	struct udf_inode_info *dinfo;

  	fibh->sbh = fibh->ebh = NULL;
  	name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
  	if (!name) {
  		*err = -ENOMEM;
  		goto out_err;
  	}

  	if (dentry) {
  		if (!dentry->d_name.len) {

  			*err = -EINVAL;

  			goto out_err;

  		}

  		namelen = udf_put_filename(sb, dentry->d_name.name, name,
  						 dentry->d_name.len);
  		if (!namelen) {

  			*err = -ENAMETOOLONG;

  			goto out_err;

  		}

  	} else {

  		namelen = 0;

  	}

  
  	nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;

  	f_pos = udf_ext0_offset(dir);

  	fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1);

  	dinfo = UDF_I(dir);

  	if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
  		if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos,
  		    &eloc, &elen, &offset) != (EXT_RECORDED_ALLOCATED >> 30)) {
  			block = udf_get_lb_pblock(dir->i_sb,

  					&dinfo->i_location, 0);

  			fibh->soffset = fibh->eoffset = sb->s_blocksize;
  			goto add;
  		}

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

  		if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {

  			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);

  		} else

  			offset = 0;

  		fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
  		if (!fibh->sbh) {

  			*err = -EIO;

  			goto out_err;

  		}

  		block = dinfo->i_location.logicalBlockNum;

  	}

  	while (f_pos < size) {

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

  		if (!fi) {

  			*err = -EIO;

  			goto out_err;

  		}
  
  		liu = le16_to_cpu(cfi->lengthOfImpUse);
  		lfi = cfi->lengthFileIdent;

  		if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {

  			if (((sizeof(struct fileIdentDesc) +
  					liu + lfi + 3) & ~3) == nfidlen) {

  				cfi->descTag.tagSerialNum = cpu_to_le16(1);
  				cfi->fileVersionNum = cpu_to_le16(1);
  				cfi->fileCharacteristics = 0;
  				cfi->lengthFileIdent = namelen;
  				cfi->lengthOfImpUse = cpu_to_le16(0);

  				if (!udf_write_fi(dir, cfi, fi, fibh, NULL,
  						  name))

  					goto out_ok;

  				else {

  					*err = -EIO;

  					goto out_err;

  				}
  			}
  		}

  	}

  add:

  	f_pos += nfidlen;

  	if (dinfo->i_alloc_type == 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);

  		if (fibh->sbh != fibh->ebh)

  			brelse(fibh->ebh);
  		brelse(fibh->sbh);

  		fibh->sbh = fibh->ebh =
  				udf_expand_dir_adinicb(dir, &block, err);
  		if (!fibh->sbh)

  			goto out_err;

  		epos.block = dinfo->i_location;

  		epos.offset = udf_file_entry_alloc_offset(dir);

  		/* Load extent udf_expand_dir_adinicb() has created */
  		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;

  		if (fibh->sbh != fibh->ebh) {

  			brelse(fibh->sbh);

  			fibh->sbh = fibh->ebh;
  		}

  		if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
  			block = dinfo->i_location.logicalBlockNum;

  			fi = (struct fileIdentDesc *)

  					(dinfo->i_ext.i_data +

  					 fibh->soffset -

  					 udf_ext0_offset(dir) +

  					 dinfo->i_lenEAttr);

  		} else {

  			block = eloc.logicalBlockNum +
  					((elen - 1) >>
  						dir->i_sb->s_blocksize_bits);
  			fi = (struct fileIdentDesc *)
  				(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) {

  			brelse(fibh->sbh);

  			fibh->sbh = fibh->ebh;
  		}
  
  		block = eloc.logicalBlockNum + ((elen - 1) >>

  						dir->i_sb->s_blocksize_bits);

  		fibh->ebh = udf_bread(dir,

  				f_pos >> dir->i_sb->s_blocksize_bits, 1, err);

  		if (!fibh->ebh)
  			goto out_err;

  		/* Extents could have been merged, invalidate our position */
  		brelse(epos.bh);
  		epos.bh = NULL;
  		epos.block = dinfo->i_location;
  		epos.offset = udf_file_entry_alloc_offset(dir);

  		if (!fibh->soffset) {

  			/* Find the freshly allocated block */
  			while (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
  				(EXT_RECORDED_ALLOCATED >> 30))
  				;
  			block = eloc.logicalBlockNum + ((elen - 1) >>

  					dir->i_sb->s_blocksize_bits);

  			brelse(fibh->sbh);

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

  		} else {

  			fi = (struct fileIdentDesc *)

  				(fibh->sbh->b_data + sb->s_blocksize +
  					fibh->soffset);

  		}
  	}
  
  	memset(cfi, 0, sizeof(struct fileIdentDesc));

  	if (UDF_SB(sb)->s_udfrev >= 0x0200)

  		udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block,

  			    sizeof(struct tag));

  	else

  		udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block,

  			    sizeof(struct tag));

  	cfi->fileVersionNum = cpu_to_le16(1);
  	cfi->lengthFileIdent = namelen;
  	cfi->lengthOfImpUse = cpu_to_le16(0);

  	if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {

  		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 {

  		*err = -EIO;

  		goto out_err;

  	}

  
  out_err:
  	fi = NULL;
  	if (fibh->sbh != fibh->ebh)
  		brelse(fibh->ebh);
  	brelse(fibh->sbh);
  out_ok:
  	brelse(epos.bh);
  	kfree(name);
  	return fi;

  }
  
  static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,

  			    struct udf_fileident_bh *fibh,
  			    struct fileIdentDesc *cfi)

  {
  	cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED;

  	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))

  		memset(&(cfi->icb), 0x00, sizeof(struct long_ad));

  	return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
  }

  static int udf_create(struct inode *dir, struct dentry *dentry, umode_t mode,

  		      bool excl)

  {
  	struct udf_fileident_bh fibh;
  	struct inode *inode;
  	struct fileIdentDesc cfi, *fi;
  	int err;

  	struct udf_inode_info *iinfo;

  	inode = udf_new_inode(dir, mode, &err);

  	if (!inode) {

  		return err;
  	}

  	iinfo = UDF_I(inode);
  	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  		inode->i_data.a_ops = &udf_adinicb_aops;
  	else
  		inode->i_data.a_ops = &udf_aops;
  	inode->i_op = &udf_file_inode_operations;
  	inode->i_fop = &udf_file_operations;

  	mark_inode_dirty(inode);

  	fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
  	if (!fi) {

  		inode_dec_link_count(inode);

  		iput(inode);

  		return err;
  	}
  	cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

  	cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);

  	*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =

  		cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);

  	udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);

  	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  		mark_inode_dirty(dir);

  	if (fibh.sbh != fibh.ebh)

  		brelse(fibh.ebh);
  	brelse(fibh.sbh);

  	d_instantiate(dentry, inode);

  	return 0;
  }

  static int udf_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,

  		     dev_t rdev)

  {

  	struct inode *inode;

  	struct udf_fileident_bh fibh;
  	struct fileIdentDesc cfi, *fi;
  	int err;

  	struct udf_inode_info *iinfo;

  
  	if (!old_valid_dev(rdev))
  		return -EINVAL;

  	err = -EIO;
  	inode = udf_new_inode(dir, mode, &err);
  	if (!inode)
  		goto out;

  	iinfo = UDF_I(inode);

  	init_special_inode(inode, mode, rdev);

  	fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
  	if (!fi) {

  		inode_dec_link_count(inode);

  		iput(inode);

  		return err;
  	}
  	cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

  	cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);

  	*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =

  		cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);

  	udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);

  	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  		mark_inode_dirty(dir);

  	mark_inode_dirty(inode);
  
  	if (fibh.sbh != fibh.ebh)

  		brelse(fibh.ebh);
  	brelse(fibh.sbh);

  	d_instantiate(dentry, inode);
  	err = 0;

  
  out:

  	return err;
  }

  static int udf_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)

  {

  	struct inode *inode;

  	struct udf_fileident_bh fibh;
  	struct fileIdentDesc cfi, *fi;
  	int err;

  	struct udf_inode_info *dinfo = UDF_I(dir);
  	struct udf_inode_info *iinfo;

  	err = -EIO;

  	inode = udf_new_inode(dir, S_IFDIR | mode, &err);

  	if (!inode)
  		goto out;

  	iinfo = UDF_I(inode);

  	inode->i_op = &udf_dir_inode_operations;
  	inode->i_fop = &udf_dir_operations;

  	fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
  	if (!fi) {

  		inode_dec_link_count(inode);

  		iput(inode);
  		goto out;
  	}

  	set_nlink(inode, 2);

  	cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

  	cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location);

  	*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =

  		cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);

  	cfi.fileCharacteristics =
  			FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;

  	udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);

  	brelse(fibh.sbh);

  	mark_inode_dirty(inode);

  	fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
  	if (!fi) {

  		clear_nlink(inode);

  		mark_inode_dirty(inode);
  		iput(inode);
  		goto out;
  	}
  	cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

  	cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);

  	*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =

  		cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);

  	cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
  	udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);

  	inc_nlink(dir);

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

  		brelse(fibh.ebh);
  	brelse(fibh.sbh);

  	err = 0;

  
  out:

  	return err;
  }
  
  static int empty_dir(struct inode *dir)
  {
  	struct fileIdentDesc *fi, cfi;
  	struct udf_fileident_bh fibh;
  	loff_t f_pos;

  	loff_t size = udf_ext0_offset(dir) + dir->i_size;

  	int block;

  	struct kernel_lb_addr eloc;

  	uint32_t elen;

  	sector_t offset;

  	struct extent_position epos = {};

  	struct udf_inode_info *dinfo = UDF_I(dir);

  	f_pos = udf_ext0_offset(dir);
  	fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1);

  	if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  		fibh.sbh = fibh.ebh = NULL;

  	else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits,

  			      &epos, &eloc, &elen, &offset) ==
  					(EXT_RECORDED_ALLOCATED >> 30)) {

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

  		if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {

  			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);

  		} else

  			offset = 0;

  		fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block);
  		if (!fibh.sbh) {

  			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;
  }

  static int udf_rmdir(struct inode *dir, struct dentry *dentry)

  {
  	int retval;

  	struct inode *inode = dentry->d_inode;

  	struct udf_fileident_bh fibh;
  	struct fileIdentDesc *fi, cfi;

  	struct kernel_lb_addr tloc;

  
  	retval = -ENOENT;

  	fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);

  	if (!fi)
  		goto out;
  
  	retval = -EIO;
  	tloc = lelb_to_cpu(cfi.icb.extLocation);

  	if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)

  		goto end_rmdir;
  	retval = -ENOTEMPTY;
  	if (!empty_dir(inode))
  		goto end_rmdir;
  	retval = udf_delete_entry(dir, fi, &fibh, &cfi);
  	if (retval)
  		goto end_rmdir;
  	if (inode->i_nlink != 2)

  		udf_warn(inode->i_sb, "empty directory has nlink != 2 (%d)
  ",
  			 inode->i_nlink);

  	clear_nlink(inode);

  	inode->i_size = 0;

  	inode_dec_link_count(dir);

  	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:

  	return retval;
  }

  static int udf_unlink(struct inode *dir, struct dentry *dentry)

  {
  	int retval;

  	struct inode *inode = dentry->d_inode;

  	struct udf_fileident_bh fibh;
  	struct fileIdentDesc *fi;
  	struct fileIdentDesc cfi;

  	struct kernel_lb_addr tloc;

  
  	retval = -ENOENT;

  	fi = udf_find_entry(dir, &dentry->d_name, &fibh, &cfi);

  	if (!fi)
  		goto out;
  
  	retval = -EIO;
  	tloc = lelb_to_cpu(cfi.icb.extLocation);

  	if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino)

  		goto end_unlink;

  	if (!inode->i_nlink) {

  		udf_debug("Deleting nonexistent file (%lu), %d
  ",

  			  inode->i_ino, inode->i_nlink);

  		set_nlink(inode, 1);

  	}
  	retval = udf_delete_entry(dir, fi, &fibh, &cfi);
  	if (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);

  	inode->i_ctime = dir->i_ctime;
  	retval = 0;

  end_unlink:

  	if (fibh.sbh != fibh.ebh)

  		brelse(fibh.ebh);
  	brelse(fibh.sbh);

  
  out:

  	return retval;
  }

  static int udf_symlink(struct inode *dir, struct dentry *dentry,
  		       const char *symname)

  {

  	struct inode *inode;

  	struct pathComponent *pc;

  	const char *compstart;

  	struct udf_fileident_bh fibh;

  	struct extent_position epos = {};

  	int eoffset, elen = 0;
  	struct fileIdentDesc *fi;
  	struct fileIdentDesc cfi;

  	uint8_t *ea;

  	int err;
  	int block;

  	unsigned char *name = NULL;

  	int namelen;

  	struct udf_inode_info *iinfo;

  	struct super_block *sb = dir->i_sb;

  	inode = udf_new_inode(dir, S_IFLNK | S_IRWXUGO, &err);

  	if (!inode)

  		goto out;

  	iinfo = UDF_I(inode);
  	down_write(&iinfo->i_data_sem);

  	name = kmalloc(UDF_NAME_LEN, GFP_NOFS);
  	if (!name) {
  		err = -ENOMEM;
  		goto out_no_entry;
  	}

  	inode->i_data.a_ops = &udf_symlink_aops;

  	inode->i_op = &udf_symlink_inode_operations;

  	if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {

  		struct kernel_lb_addr eloc;

  		uint32_t bsize;

  		block = udf_new_block(sb, inode,

  				iinfo->i_location.partitionReferenceNum,
  				iinfo->i_location.logicalBlockNum, &err);

  		if (!block)
  			goto out_no_entry;

  		epos.block = iinfo->i_location;

  		epos.offset = udf_file_entry_alloc_offset(inode);
  		epos.bh = NULL;

  		eloc.logicalBlockNum = block;

  		eloc.partitionReferenceNum =

  				iinfo->i_location.partitionReferenceNum;

  		bsize = sb->s_blocksize;

  		iinfo->i_lenExtents = bsize;

  		udf_add_aext(inode, &epos, &eloc, bsize, 0);

  		brelse(epos.bh);

  		block = udf_get_pblock(sb, block,

  				iinfo->i_location.partitionReferenceNum,

  				0);

  		epos.bh = udf_tgetblk(sb, block);

  		lock_buffer(epos.bh);

  		memset(epos.bh->b_data, 0x00, bsize);

  		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 = iinfo->i_ext.i_data + iinfo->i_lenEAttr;

  	eoffset = sb->s_blocksize - udf_ext0_offset(inode);

  	pc = (struct pathComponent *)ea;

  	if (*symname == '/') {
  		do {

  			symname++;
  		} while (*symname == '/');
  
  		pc->componentType = 1;
  		pc->lengthComponentIdent = 0;
  		pc->componentFileVersionNum = 0;

  		elen += sizeof(struct pathComponent);
  	}
  
  	err = -ENAMETOOLONG;

  	while (*symname) {

  		if (elen + sizeof(struct pathComponent) > eoffset)
  			goto out_no_entry;
  
  		pc = (struct pathComponent *)(ea + elen);

  		compstart = symname;

  		do {

  			symname++;
  		} while (*symname && *symname != '/');
  
  		pc->componentType = 5;
  		pc->lengthComponentIdent = 0;
  		pc->componentFileVersionNum = 0;

  		if (compstart[0] == '.') {
  			if ((symname - compstart) == 1)

  				pc->componentType = 4;

  			else if ((symname - compstart) == 2 &&
  					compstart[1] == '.')

  				pc->componentType = 3;
  		}

  		if (pc->componentType == 5) {

  			namelen = udf_put_filename(sb, compstart, name,

  						   symname - compstart);
  			if (!namelen)

  				goto out_no_entry;

  			if (elen + sizeof(struct pathComponent) + namelen >
  					eoffset)

  				goto out_no_entry;
  			else
  				pc->lengthComponentIdent = namelen;
  
  			memcpy(pc->componentIdent, name, namelen);
  		}
  
  		elen += sizeof(struct pathComponent) + pc->lengthComponentIdent;

  		if (*symname) {
  			do {

  				symname++;
  			} while (*symname == '/');
  		}
  	}

  	brelse(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);
  	if (!fi)

  		goto out_no_entry;

  	cfi.icb.extLength = cpu_to_le32(sb->s_blocksize);

  	cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);

  	if (UDF_SB(inode->i_sb)->s_lvid_bh) {

  		*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =

  			cpu_to_le32(lvid_get_unique_id(sb));

  	}
  	udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);

  	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  		mark_inode_dirty(dir);

  	up_write(&iinfo->i_data_sem);

  	if (fibh.sbh != fibh.ebh)

  		brelse(fibh.ebh);
  	brelse(fibh.sbh);

  	d_instantiate(dentry, inode);
  	err = 0;

  out:

  	kfree(name);

  	return err;

  out_no_entry:

  	up_write(&iinfo->i_data_sem);

  	inode_dec_link_count(inode);

  	iput(inode);
  	goto out;
  }

  static int udf_link(struct dentry *old_dentry, struct inode *dir,
  		    struct dentry *dentry)

  {
  	struct inode *inode = old_dentry->d_inode;
  	struct udf_fileident_bh fibh;
  	struct fileIdentDesc cfi, *fi;
  	int err;

  	fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
  	if (!fi) {

  		return err;
  	}
  	cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);

  	cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);

  	if (UDF_SB(inode->i_sb)->s_lvid_bh) {

  		*(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =

  			cpu_to_le32(lvid_get_unique_id(inode->i_sb));

  	}
  	udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);

  	if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  		mark_inode_dirty(dir);

  	if (fibh.sbh != fibh.ebh)

  		brelse(fibh.ebh);
  	brelse(fibh.sbh);

  	inc_nlink(inode);

  	inode->i_ctime = current_fs_time(inode->i_sb);
  	mark_inode_dirty(inode);

  	ihold(inode);

  	d_instantiate(dentry, inode);

  	return 0;
  }
  
  /* Anybody can rename anything with this: the permission checks are left to the
   * higher-level routines.
   */

  static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
  		      struct inode *new_dir, struct dentry *new_dentry)

  {

  	struct inode *old_inode = old_dentry->d_inode;
  	struct inode *new_inode = new_dentry->d_inode;

  	struct udf_fileident_bh ofibh, nfibh;

  	struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
  	struct fileIdentDesc ocfi, ncfi;

  	struct buffer_head *dir_bh = NULL;
  	int retval = -ENOENT;

  	struct kernel_lb_addr tloc;

  	struct udf_inode_info *old_iinfo = UDF_I(old_inode);

  	ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);

  	if (ofi) {

  		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)

  	    != old_inode->i_ino)

  		goto end_rename;

  	nfi = udf_find_entry(new_dir, &new_dentry->d_name, &nfibh, &ncfi);

  	if (nfi) {
  		if (!new_inode) {

  			if (nfibh.sbh != nfibh.ebh)

  				brelse(nfibh.ebh);
  			brelse(nfibh.sbh);

  			nfi = NULL;
  		}
  	}

  	if (S_ISDIR(old_inode->i_mode)) {

  		int offset = udf_ext0_offset(old_inode);

  		if (new_inode) {

  			retval = -ENOTEMPTY;
  			if (!empty_dir(new_inode))
  				goto end_rename;
  		}
  		retval = -EIO;

  		if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {

  			dir_fi = udf_get_fileident(

  					old_iinfo->i_ext.i_data -
  					  (old_iinfo->i_efe ?

  					   sizeof(struct extendedFileEntry) :
  					   sizeof(struct fileEntry)),
  					old_inode->i_sb->s_blocksize, &offset);

  		} else {

  			dir_bh = udf_bread(old_inode, 0, 0, &retval);
  			if (!dir_bh)
  				goto end_rename;

  			dir_fi = udf_get_fileident(dir_bh->b_data,
  					old_inode->i_sb->s_blocksize, &offset);

  		}
  		if (!dir_fi)
  			goto end_rename;
  		tloc = lelb_to_cpu(dir_fi->icb.extLocation);

  		if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) !=

  				old_dir->i_ino)

  			goto end_rename;

  	}

  	if (!nfi) {

  		nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi,
  				    &retval);

  		if (!nfi)
  			goto end_rename;
  	}
  
  	/*
  	 * Like most other Unix systems, set the ctime for inodes on a
  	 * rename.
  	 */
  	old_inode->i_ctime = current_fs_time(old_inode->i_sb);
  	mark_inode_dirty(old_inode);
  
  	/*
  	 * ok, that's it
  	 */
  	ncfi.fileVersionNum = ocfi.fileVersionNum;
  	ncfi.fileCharacteristics = ocfi.fileCharacteristics;

  	memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(struct long_ad));

  	udf_write_fi(new_dir, &ncfi, nfi, &nfibh, NULL, NULL);
  
  	/* The old fid may have moved - find it again */

  	ofi = udf_find_entry(old_dir, &old_dentry->d_name, &ofibh, &ocfi);

  	udf_delete_entry(old_dir, ofi, &ofibh, &ocfi);

  	if (new_inode) {

  		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);

  	if (dir_fi) {

  		dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);

  		udf_update_tag((char *)dir_fi,
  				(sizeof(struct fileIdentDesc) +
  				le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);

  		if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)

  			mark_inode_dirty(old_inode);

  		else

  			mark_buffer_dirty_inode(dir_bh, old_inode);

  		inode_dec_link_count(old_dir);

  		if (new_inode)

  			inode_dec_link_count(new_inode);

  		else {

  			inc_nlink(new_dir);

  			mark_inode_dirty(new_dir);
  		}
  	}

  	if (ofi) {

  		if (ofibh.sbh != ofibh.ebh)

  			brelse(ofibh.ebh);
  		brelse(ofibh.sbh);

  	}
  
  	retval = 0;

  end_rename: