patch-2.4.4 linux/fs/affs/inode.c

• Lines: 618
• Date: Wed Apr 25 14:35:25 2001
• Orig file: v2.4.3/linux/fs/affs/inode.c
• Orig date: Fri Feb 9 11:29:44 2001

diff -u --recursive --new-file v2.4.3/linux/fs/affs/inode.c linux/fs/affs/inode.c
@@ -10,7 +10,6 @@
  *  (C) 1991  Linus Torvalds - minix filesystem
  */
 
-#define DEBUG 0
 #include <asm/div64.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
@@ -31,209 +30,185 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 
-extern int *blk_size[];
-extern struct timezone sys_tz;
 extern struct inode_operations affs_symlink_inode_operations;
-
-#define MIN(a,b) (((a)<(b))?(a):(b))
-
-unsigned long
-affs_parent_ino(struct inode *dir)
-{
-	int root_ino = (dir->i_sb->u.affs_sb.s_root_block);
-
-	if (!S_ISDIR(dir->i_mode)) {
-		affs_error(dir->i_sb,"parent_ino","Trying to get parent of non-directory");
-		return root_ino;
-	}
-	if (dir->i_ino == root_ino)
-		return root_ino;
-	return dir->u.affs_i.i_parent;
-}
+extern struct timezone sys_tz;
 
 void
 affs_read_inode(struct inode *inode)
 {
+	struct super_block	*sb = inode->i_sb;
 	struct buffer_head	*bh;
-	struct file_front	*file_front;
-	struct file_end		*file_end;
-	s32			 block;
-	unsigned long		 prot;
-	s32			 ptype, stype;
-	unsigned short		 id;
-	loff_t		tmp;
+	struct affs_head	*head;
+	struct affs_tail	*tail;
+	u32			 block;
+	u32			 size;
+	u32			 prot;
+	u16			 id;
 
 	pr_debug("AFFS: read_inode(%lu)\n",inode->i_ino);
 
 	block = inode->i_ino;
-	if (!(bh = affs_bread(inode->i_dev,block,AFFS_I2BSIZE(inode)))) {
-		affs_error(inode->i_sb,"read_inode","Cannot read block %d",block);
-		return;
-	}
-	if (affs_checksum_block(AFFS_I2BSIZE(inode),bh->b_data,&ptype,&stype) || ptype != T_SHORT) {
-		affs_error(inode->i_sb,"read_inode",
-			   "Checksum or type (ptype=%d) error on inode %d",ptype,block);
-		affs_brelse(bh);
-		return;
+	bh = affs_bread(sb, block);
+	if (!bh) {
+		affs_warning(sb, "read_inode", "Cannot read block %d", block);
+		goto bad_inode;
+	}
+	if (affs_checksum_block(sb, bh) || be32_to_cpu(AFFS_HEAD(bh)->ptype) != T_SHORT) {
+		affs_warning(sb,"read_inode",
+			   "Checksum or type (ptype=%d) error on inode %d",
+			   AFFS_HEAD(bh)->ptype, block);
+		goto bad_inode;
 	}
 
-	file_front = (struct file_front *)bh->b_data;
-	file_end   = GET_END_PTR(struct file_end, bh->b_data,AFFS_I2BSIZE(inode));
-	prot       = (be32_to_cpu(file_end->protect) & ~0x10) ^ FIBF_OWNER;
-
-	inode->u.affs_i.i_protect      = prot;
-	inode->u.affs_i.i_parent       = be32_to_cpu(file_end->parent);
-	inode->u.affs_i.i_original     = 0;
-	inode->u.affs_i.i_zone         = 0;
-	inode->u.affs_i.i_hlink        = 0;
-	inode->u.affs_i.i_pa_cnt       = 0;
-	inode->u.affs_i.i_pa_next      = 0;
-	inode->u.affs_i.i_pa_last      = 0;
-	inode->u.affs_i.i_ec           = NULL;
-	inode->u.affs_i.i_lastblock    = -1;
-	inode->i_nlink                 = 1;
-	inode->i_mode                  = 0;
+	head = AFFS_HEAD(bh);
+	tail = AFFS_TAIL(sb, bh);
+	prot = be32_to_cpu(tail->protect);
 
-	if (inode->i_sb->u.affs_sb.s_flags & SF_SETMODE)
-		inode->i_mode = inode->i_sb->u.affs_sb.s_mode;
+	inode->i_size = 0;
+	inode->i_nlink = 1;
+	inode->i_mode = 0;
+	memset(AFFS_INODE, 0, sizeof(struct affs_inode_info));
+	init_MUTEX(&AFFS_INODE->i_link_lock);
+	init_MUTEX(&AFFS_INODE->i_ext_lock);
+	AFFS_INODE->i_extcnt = 1;
+	AFFS_INODE->i_ext_last = ~1;
+	AFFS_INODE->i_protect = prot;
+
+	if (AFFS_SB->s_flags & SF_SETMODE)
+		inode->i_mode = AFFS_SB->s_mode;
 	else
 		inode->i_mode = prot_to_mode(prot);
 
-	if (inode->i_sb->u.affs_sb.s_flags & SF_SETUID)
-		inode->i_uid = inode->i_sb->u.affs_sb.s_uid;
-	id = be16_to_cpu(file_end->owner_uid);
-	if (id == 0 || inode->i_sb->u.affs_sb.s_flags & SF_SETUID)
-		inode->i_uid = inode->i_sb->u.affs_sb.s_uid;
-	else if (id == 0xFFFF && inode->i_sb->u.affs_sb.s_flags & SF_MUFS)
+	id = be16_to_cpu(tail->uid);
+	if (id == 0 || AFFS_SB->s_flags & SF_SETUID)
+		inode->i_uid = AFFS_SB->s_uid;
+	else if (id == 0xFFFF && AFFS_SB->s_flags & SF_MUFS)
 		inode->i_uid = 0;
-	else 
+	else
 		inode->i_uid = id;
 
-	id = be16_to_cpu(file_end->owner_gid);
-	if (id == 0 || inode->i_sb->u.affs_sb.s_flags & SF_SETGID)
-		inode->i_gid = inode->i_sb->u.affs_sb.s_gid;
-	else if (id == 0xFFFF && inode->i_sb->u.affs_sb.s_flags & SF_MUFS)
+	id = be16_to_cpu(tail->gid);
+	if (id == 0 || AFFS_SB->s_flags & SF_SETGID)
+		inode->i_gid = AFFS_SB->s_gid;
+	else if (id == 0xFFFF && AFFS_SB->s_flags & SF_MUFS)
 		inode->i_gid = 0;
 	else
 		inode->i_gid = id;
 
-	switch (be32_to_cpu(file_end->secondary_type)) {
-		case ST_ROOT:
-			inode->i_uid   = inode->i_sb->u.affs_sb.s_uid;
-			inode->i_gid   = inode->i_sb->u.affs_sb.s_gid;
-		case ST_USERDIR:
-			if (be32_to_cpu(file_end->secondary_type) == ST_USERDIR ||
-			    inode->i_sb->u.affs_sb.s_flags & SF_SETMODE) {
-				if (inode->i_mode & S_IRUSR)
-					inode->i_mode |= S_IXUSR;
-				if (inode->i_mode & S_IRGRP)
-					inode->i_mode |= S_IXGRP;
-				if (inode->i_mode & S_IROTH)
-					inode->i_mode |= S_IXOTH;
-				inode->i_mode |= S_IFDIR;
-			} else
-				inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR;
-			inode->i_size  = 0;
-			break;
-		case ST_LINKDIR:
-			affs_error(inode->i_sb,"read_inode","inode is LINKDIR");
-			affs_brelse(bh);
-			return;
-		case ST_LINKFILE:
-			affs_error(inode->i_sb,"read_inode","inode is LINKFILE");
-			affs_brelse(bh);
-			return;
-		case ST_FILE:
-			inode->i_mode |= S_IFREG;
-			inode->i_size  = be32_to_cpu(file_end->byte_size);
-			if (inode->i_sb->u.affs_sb.s_flags & SF_OFS)
-				block = AFFS_I2BSIZE(inode) - 24;
-			else
-				block = AFFS_I2BSIZE(inode);
-			tmp = inode->i_size + block -1;
-			do_div (tmp, block);
-			tmp--;
-			inode->u.affs_i.i_lastblock = tmp;
-			break;
-		case ST_SOFTLINK:
-			inode->i_mode |= S_IFLNK;
-			inode->i_size  = 0;
-			break;
+	switch (be32_to_cpu(tail->stype)) {
+	case ST_ROOT:
+		inode->i_uid = AFFS_SB->s_uid;
+		inode->i_gid = AFFS_SB->s_gid;
+		/* fall through */
+	case ST_USERDIR:
+		if (be32_to_cpu(tail->stype) == ST_USERDIR ||
+		    AFFS_SB->s_flags & SF_SETMODE) {
+			if (inode->i_mode & S_IRUSR)
+				inode->i_mode |= S_IXUSR;
+			if (inode->i_mode & S_IRGRP)
+				inode->i_mode |= S_IXGRP;
+			if (inode->i_mode & S_IROTH)
+				inode->i_mode |= S_IXOTH;
+			inode->i_mode |= S_IFDIR;
+		} else
+			inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR;
+		if (tail->link_chain)
+			inode->i_nlink = 2;
+		/* Maybe it should be controlled by mount parameter? */
+		//inode->i_mode |= S_ISVTX;
+		inode->i_op = &affs_dir_inode_operations;
+		inode->i_fop = &affs_dir_operations;
+		break;
+	case ST_LINKDIR:
+		affs_warning(sb, "read_inode", "inode is LINKDIR");
+		goto bad_inode;
+	case ST_LINKFILE:
+		affs_warning(sb, "read_inode", "inode is LINKFILE");
+		goto bad_inode;
+	case ST_FILE:
+		size = be32_to_cpu(tail->size);
+		inode->i_mode |= S_IFREG;
+		AFFS_INODE->mmu_private = inode->i_size = size;
+		if (inode->i_size) {
+			AFFS_INODE->i_blkcnt = (size - 1) /
+					       AFFS_SB->s_data_blksize + 1;
+			AFFS_INODE->i_extcnt = (AFFS_INODE->i_blkcnt - 1) /
+					       AFFS_SB->s_hashsize + 1;
+		}
+		if (tail->link_chain)
+			inode->i_nlink = 2;
+		inode->i_mapping->a_ops = (AFFS_SB->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops;
+		inode->i_op = &affs_file_inode_operations;
+		inode->i_fop = &affs_file_operations;
+		break;
+	case ST_SOFTLINK:
+		inode->i_mode |= S_IFLNK;
+		inode->i_op = &affs_symlink_inode_operations;
+		inode->i_data.a_ops = &affs_symlink_aops;
+		break;
 	}
 
 	inode->i_mtime = inode->i_atime = inode->i_ctime
-		       = (be32_to_cpu(file_end->created.ds_Days) * (24 * 60 * 60) +
-		         be32_to_cpu(file_end->created.ds_Minute) * 60 +
-			 be32_to_cpu(file_end->created.ds_Tick) / 50 +
+		       = (be32_to_cpu(tail->change.days) * (24 * 60 * 60) +
+		         be32_to_cpu(tail->change.mins) * 60 +
+			 be32_to_cpu(tail->change.ticks) / 50 +
 			 ((8 * 365 + 2) * 24 * 60 * 60)) +
 			 sys_tz.tz_minuteswest * 60;
 	affs_brelse(bh);
+	return;
 
-	if (S_ISREG(inode->i_mode)) {
-		if (inode->i_sb->u.affs_sb.s_flags & SF_OFS) {
-			inode->i_op = &affs_file_inode_operations;
-			inode->i_fop = &affs_file_operations_ofs;
-			return;
-		}
-		inode->i_op = &affs_file_inode_operations;
-		inode->i_fop = &affs_file_operations;
-		inode->i_mapping->a_ops = &affs_aops;
-		inode->u.affs_i.mmu_private = inode->i_size;
-	} else if (S_ISDIR(inode->i_mode)) {
-		/* Maybe it should be controlled by mount parameter? */
-		inode->i_mode |= S_ISVTX;
-		inode->i_op = &affs_dir_inode_operations;
-		inode->i_fop = &affs_dir_operations;
-	}
-	else if (S_ISLNK(inode->i_mode)) {
-		inode->i_op = &affs_symlink_inode_operations;
-		inode->i_data.a_ops = &affs_symlink_aops;
-	}
+bad_inode:
+	make_bad_inode(inode);
+	affs_brelse(bh);
+	return;
 }
 
 void
 affs_write_inode(struct inode *inode, int unused)
 {
+	struct super_block	*sb = inode->i_sb;
 	struct buffer_head	*bh;
-	struct file_end		*file_end;
+	struct affs_tail	*tail;
 	uid_t			 uid;
 	gid_t			 gid;
 
 	pr_debug("AFFS: write_inode(%lu)\n",inode->i_ino);
 
 	if (!inode->i_nlink)
+		// possibly free block
 		return;
 	lock_kernel();
-	if (!(bh = bread(inode->i_dev,inode->i_ino,AFFS_I2BSIZE(inode)))) {
-		affs_error(inode->i_sb,"write_inode","Cannot read block %lu",inode->i_ino);
+	bh = affs_bread(sb, inode->i_ino);
+	if (!bh) {
+		affs_error(sb,"write_inode","Cannot read block %lu",inode->i_ino);
 		unlock_kernel();
 		return;
 	}
-	file_end = GET_END_PTR(struct file_end, bh->b_data,AFFS_I2BSIZE(inode));
-	if (file_end->secondary_type == be32_to_cpu(ST_ROOT)) {
-		secs_to_datestamp(inode->i_mtime,&ROOT_END(bh->b_data,inode)->disk_altered);
+	tail = AFFS_TAIL(sb, bh);
+	if (tail->stype == be32_to_cpu(ST_ROOT)) {
+		secs_to_datestamp(inode->i_mtime,&AFFS_ROOT_TAIL(sb, bh)->root_change);
 	} else {
-		file_end->protect   = cpu_to_be32(inode->u.affs_i.i_protect ^ FIBF_OWNER);
-		file_end->byte_size = cpu_to_be32(inode->i_size);
-		secs_to_datestamp(inode->i_mtime,&file_end->created);
-		if (!(inode->i_ino == inode->i_sb->u.affs_sb.s_root_block)) {
+		tail->protect = cpu_to_be32(AFFS_INODE->i_protect);
+		tail->size = cpu_to_be32(inode->i_size);
+		secs_to_datestamp(inode->i_mtime,&tail->change);
+		if (!(inode->i_ino == AFFS_SB->s_root_block)) {
 			uid = inode->i_uid;
 			gid = inode->i_gid;
-			if (inode->i_sb->u.affs_sb.s_flags & SF_MUFS) {
+			if (sb->u.affs_sb.s_flags & SF_MUFS) {
 				if (inode->i_uid == 0 || inode->i_uid == 0xFFFF)
 					uid = inode->i_uid ^ ~0;
 				if (inode->i_gid == 0 || inode->i_gid == 0xFFFF)
 					gid = inode->i_gid ^ ~0;
 			}
-			if (!(inode->i_sb->u.affs_sb.s_flags & SF_SETUID))
-				file_end->owner_uid = cpu_to_be16(uid);
-			if (!(inode->i_sb->u.affs_sb.s_flags & SF_SETGID))
-				file_end->owner_gid = cpu_to_be16(gid);
+			if (!(sb->u.affs_sb.s_flags & SF_SETUID))
+				tail->uid = cpu_to_be16(uid);
+			if (!(sb->u.affs_sb.s_flags & SF_SETGID))
+				tail->gid = cpu_to_be16(gid);
 		}
 	}
-	affs_fix_checksum(AFFS_I2BSIZE(inode),bh->b_data,5);
+	affs_fix_checksum(sb, bh);
 	mark_buffer_dirty(bh);
-	brelse(bh);
+	affs_brelse(bh);
 	unlock_kernel();
 }
 
@@ -258,11 +233,9 @@
 		goto out;
 	}
 
-	if (attr->ia_valid & ATTR_MODE)
-		inode->u.affs_i.i_protect = mode_to_prot(attr->ia_mode);
-
-	error = 0;
 	inode_setattr(inode, attr);
+	if (!error && (attr->ia_valid & ATTR_MODE))
+		mode_to_prot(inode);
 out:
 	return error;
 }
@@ -270,18 +243,14 @@
 void
 affs_put_inode(struct inode *inode)
 {
-	pr_debug("AFFS: put_inode(ino=%lu, nlink=%u)\n",
-		inode->i_ino,inode->i_nlink);
-
+	pr_debug("AFFS: put_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
 	lock_kernel();
 	affs_free_prealloc(inode);
 	if (atomic_read(&inode->i_count) == 1) {
-		unsigned long cache_page = (unsigned long) inode->u.affs_i.i_ec;
-		if (cache_page) {
-			pr_debug("AFFS: freeing ext cache\n");
-			inode->u.affs_i.i_ec = NULL;
-			free_page(cache_page);
-		}
+		if (inode->i_size != AFFS_INODE->mmu_private)
+			affs_truncate(inode);
+		//if (inode->i_nlink)
+		//	affs_clear_inode(inode);
 	}
 	unlock_kernel();
 }
@@ -289,55 +258,76 @@
 void
 affs_delete_inode(struct inode *inode)
 {
-	pr_debug("AFFS: delete_inode(ino=%lu, nlink=%u)\n",inode->i_ino,inode->i_nlink);
+	pr_debug("AFFS: delete_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
 	lock_kernel();
 	inode->i_size = 0;
-	if (S_ISREG(inode->i_mode) && !inode->u.affs_i.i_hlink)
+	if (S_ISREG(inode->i_mode))
 		affs_truncate(inode);
-	affs_free_block(inode->i_sb,inode->i_ino);
-	unlock_kernel();
 	clear_inode(inode);
+	affs_free_block(inode->i_sb, inode->i_ino);
+	unlock_kernel();
+}
+
+void
+affs_clear_inode(struct inode *inode)
+{
+	unsigned long cache_page = (unsigned long) inode->u.affs_i.i_lc;
+
+	pr_debug("AFFS: clear_inode(ino=%lu, nlink=%u)\n", inode->i_ino, inode->i_nlink);
+	if (cache_page) {
+		pr_debug("AFFS: freeing ext cache\n");
+		inode->u.affs_i.i_lc = NULL;
+		inode->u.affs_i.i_ac = NULL;
+		free_page(cache_page);
+	}
+	affs_brelse(AFFS_INODE->i_ext_bh);
+	AFFS_INODE->i_ext_last = ~1;
+	AFFS_INODE->i_ext_bh = NULL;
 }
 
 struct inode *
-affs_new_inode(const struct inode *dir)
+affs_new_inode(struct inode *dir)
 {
+	struct super_block	*sb = dir->i_sb;
 	struct inode		*inode;
-	struct super_block	*sb;
-	s32			 block;
+	u32			 block;
+	struct buffer_head	*bh;
 
-	if (!dir)
-		return NULL;
+	if (!dir || !(inode = get_empty_inode()))
+		goto err_inode;
 
-	sb = dir->i_sb;
-	inode = new_inode(sb);
-	if (!inode)
-		return NULL;
-
-	if (!(block = affs_new_header((struct inode *)dir))) {
-		iput(inode);
-		return NULL;
-	}
+	if (!(block = affs_alloc_block(dir, dir->i_ino)))
+		goto err_block;
+
+	bh = affs_getzeroblk(sb, block);
+	if (!bh)
+		goto err_bh;
+	mark_buffer_dirty(bh);
+	affs_brelse(bh);
 
+	inode->i_sb      = sb;
+	inode->i_dev     = sb->s_dev;
 	inode->i_uid     = current->fsuid;
 	inode->i_gid     = current->fsgid;
 	inode->i_ino     = block;
+	inode->i_nlink   = 1;
 	inode->i_mtime   = inode->i_atime = inode->i_ctime = CURRENT_TIME;
-
-	inode->u.affs_i.i_original  = 0;
-	inode->u.affs_i.i_parent    = dir->i_ino;
-	inode->u.affs_i.i_zone      = 0;
-	inode->u.affs_i.i_hlink     = 0;
-	inode->u.affs_i.i_pa_cnt    = 0;
-	inode->u.affs_i.i_pa_next   = 0;
-	inode->u.affs_i.i_pa_last   = 0;
-	inode->u.affs_i.i_ec        = NULL;
-	inode->u.affs_i.i_lastblock = -1;
+	memset(AFFS_INODE, 0, sizeof(struct affs_inode_info));
+	AFFS_INODE->i_extcnt = 1;
+	AFFS_INODE->i_ext_last = ~1;
+	init_MUTEX(&AFFS_INODE->i_link_lock);
+	init_MUTEX(&AFFS_INODE->i_ext_lock);
 
 	insert_inode_hash(inode);
-	mark_inode_dirty(inode);
 
 	return inode;
+
+err_bh:
+	affs_free_block(sb, block);
+err_block:
+	iput(inode);
+err_inode:
+	return NULL;
 }
 
 /*
@@ -346,70 +336,73 @@
  */
 
 int
-affs_add_entry(struct inode *dir, struct inode *link, struct inode *inode,
-	       struct dentry *dentry, int type)
+affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s32 type)
 {
-	struct buffer_head	*dir_bh;
-	struct buffer_head	*inode_bh;
-	struct buffer_head	*link_bh;
-	int			 retval;
-	const unsigned char	*name = dentry->d_name.name;
-	int			 len  = dentry->d_name.len;
-
-	pr_debug("AFFS: add_entry(dir=%lu,inode=%lu,\"%*s\",type=%d)\n",dir->i_ino,inode->i_ino,
-		 len,name,type);
-
-	if ((retval = affs_check_name(name,len)))
-		return retval;
-	if (len > 30)
-		len = 30;
-
-	dir_bh   = affs_bread(dir->i_dev,dir->i_ino,AFFS_I2BSIZE(dir));
-	inode_bh = affs_bread(inode->i_dev,inode->i_ino,AFFS_I2BSIZE(inode));
-	link_bh  = NULL;
-	retval   = -EIO;
-	if (!dir_bh || !inode_bh)
-		goto addentry_done;
-	if (link) {
-		link_bh = affs_bread(link->i_dev,link->i_ino,AFFS_I2BSIZE(link));
-		if (!link_bh)
-			goto addentry_done;
-	}
-	((struct dir_front *)inode_bh->b_data)->primary_type = cpu_to_be32(T_SHORT);
-	((struct dir_front *)inode_bh->b_data)->own_key      = cpu_to_be32(inode->i_ino);
-	DIR_END(inode_bh->b_data,inode)->dir_name[0]         = len;
-	strncpy(DIR_END(inode_bh->b_data,inode)->dir_name + 1,name,len);
-	DIR_END(inode_bh->b_data,inode)->secondary_type = cpu_to_be32(type);
-	DIR_END(inode_bh->b_data,inode)->parent         = cpu_to_be32(dir->i_ino);
-
-	lock_super(inode->i_sb);
-	retval = affs_insert_hash(dir->i_ino,inode_bh,dir);
-
-	if (link_bh) {
-		LINK_END(inode_bh->b_data,inode)->original   = cpu_to_be32(link->i_ino);
-		LINK_END(inode_bh->b_data,inode)->link_chain =
-						FILE_END(link_bh->b_data,link)->link_chain;
-		FILE_END(link_bh->b_data,link)->link_chain   = cpu_to_be32(inode->i_ino);
-		affs_fix_checksum(AFFS_I2BSIZE(link),link_bh->b_data,5);
-		link->i_version = ++event;
-		mark_inode_dirty(link);
-		mark_buffer_dirty(link_bh);
+	struct super_block *sb = dir->i_sb;
+	struct buffer_head *inode_bh = NULL;
+	struct buffer_head *bh = NULL;
+	u32 block = 0;
+	int retval;
+
+	pr_debug("AFFS: add_entry(dir=%u, inode=%u, \"%*s\", type=%d)\n", (u32)dir->i_ino,
+	         (u32)inode->i_ino, (int)dentry->d_name.len, dentry->d_name.name, type);
+
+	retval = -EIO;
+	bh = affs_bread(sb, inode->i_ino);
+	if (!bh)
+		goto done;
+
+	switch (type) {
+	case ST_LINKFILE:
+	case ST_LINKDIR:
+		inode_bh = bh;
+		retval = -ENOSPC;
+		block = affs_alloc_block(dir, dir->i_ino);
+		if (!block)
+			goto err;
+		retval = -EIO;
+		bh = affs_getzeroblk(sb, block);
+		if (!bh)
+			goto err;
+		break;
+	default:
+		break;
+	}
+
+	AFFS_HEAD(bh)->ptype = cpu_to_be32(T_SHORT);
+	AFFS_HEAD(bh)->key = cpu_to_be32(bh->b_blocknr);
+	affs_copy_name(AFFS_TAIL(sb, bh)->name, dentry);
+	AFFS_TAIL(sb, bh)->stype = cpu_to_be32(type);
+	AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino);
+
+	if (inode_bh) {
+		u32 chain;
+		down(&AFFS_INODE->i_link_lock);
+	       	chain = AFFS_TAIL(sb, inode_bh)->link_chain;
+		AFFS_TAIL(sb, bh)->original = cpu_to_be32(inode->i_ino);
+		AFFS_TAIL(sb, bh)->link_chain = chain;
+		AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block);
+		affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain));
+		mark_buffer_dirty(inode_bh);
+		inode->i_nlink = 2;
+		atomic_inc(&inode->i_count);
+		up(&AFFS_INODE->i_link_lock);
 	}
-	affs_fix_checksum(AFFS_I2BSIZE(inode),inode_bh->b_data,5);
-	affs_fix_checksum(AFFS_I2BSIZE(dir),dir_bh->b_data,5);
-	dir->i_version = ++event;
-	dir->i_mtime   = dir->i_atime = dir->i_ctime = CURRENT_TIME;
-	unlock_super(inode->i_sb);
-
-	mark_inode_dirty(dir);
-	mark_inode_dirty(inode);
-	mark_buffer_dirty(dir_bh);
-	mark_buffer_dirty(inode_bh);
+	affs_fix_checksum(sb, bh);
+	mark_buffer_dirty(bh);
 
-addentry_done:
-	affs_brelse(dir_bh);
+	down(&AFFS_DIR->i_hash_lock);
+	retval = affs_insert_hash(dir, bh);
+	up(&AFFS_DIR->i_hash_lock);
+
+	dentry->d_fsdata = (void *)bh->b_blocknr;
+	d_instantiate(dentry, inode);
+done:
 	affs_brelse(inode_bh);
-	affs_brelse(link_bh);
-
+	affs_brelse(bh);
 	return retval;
+err:
+	if (block)
+		affs_free_block(sb, block);
+	goto done;
 }