[linux.git] / fs / hpfs / namei.c

/*
 *  linux/fs/hpfs/namei.c
 *
 *  Mikulas Patocka ([email protected]), 1998-1999
 *
 *  adding & removing files & directories
 */
#include <linux/sched.h>
#include <linux/smp_lock.h>
#include "hpfs_fn.h"

static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	const unsigned char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct quad_buffer_head qbh0;
	struct buffer_head *bh;
	struct hpfs_dirent *de;
	struct fnode *fnode;
	struct dnode *dnode;
	struct inode *result;
	fnode_secno fno;
	dnode_secno dno;
	int r;
	struct hpfs_dirent dee;
	int err;
	if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
	lock_kernel();
	err = -ENOSPC;
	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	if (!fnode)
		goto bail;
	dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
	if (!dnode)
		goto bail1;
	memset(&dee, 0, sizeof dee);
	dee.directory = 1;
	if (!(mode & 0222)) dee.read_only = 1;
	/*dee.archive = 0;*/
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
	result = new_inode(dir->i_sb);
	if (!result)
		goto bail2;
	hpfs_init_inode(result);
	result->i_ino = fno;
	hpfs_i(result)->i_parent_dir = dir->i_ino;
	hpfs_i(result)->i_dno = dno;
	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	result->i_ctime.tv_nsec = 0; 
	result->i_mtime.tv_nsec = 0; 
	result->i_atime.tv_nsec = 0; 
	hpfs_i(result)->i_ea_size = 0;
	result->i_mode |= S_IFDIR;
	result->i_op = &hpfs_dir_iops;
	result->i_fop = &hpfs_dir_ops;
	result->i_blocks = 4;
	result->i_size = 2048;
	result->i_nlink = 2;
	if (dee.read_only)
		result->i_mode &= ~0222;

	mutex_lock(&hpfs_i(dir)->i_mutex);
	r = hpfs_add_dirent(dir, name, len, &dee, 0);
	if (r == 1)
		goto bail3;
	if (r == -1) {
		err = -EEXIST;
		goto bail3;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	fnode->dirflag = 1;
	fnode->btree.n_free_nodes = 7;
	fnode->btree.n_used_nodes = 1;
	fnode->btree.first_free = 0x14;
	fnode->u.external[0].disk_secno = dno;
	fnode->u.external[0].file_secno = -1;
	dnode->root_dnode = 1;
	dnode->up = fno;
	de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
	de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
	if (!(mode & 0222)) de->read_only = 1;
	de->first = de->directory = 1;
	/*de->hidden = de->system = 0;*/
	de->fnode = fno;
	mark_buffer_dirty(bh);
	brelse(bh);
	hpfs_mark_4buffers_dirty(&qbh0);
	hpfs_brelse4(&qbh0);
	inc_nlink(dir);
	insert_inode_hash(result);

	if (result->i_uid != current_fsuid() ||
	    result->i_gid != current_fsgid() ||
	    result->i_mode != (mode | S_IFDIR)) {
		result->i_uid = current_fsuid();
		result->i_gid = current_fsgid();
		result->i_mode = mode | S_IFDIR;
		hpfs_write_inode_nolock(result);
	}
	d_instantiate(dentry, result);
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	unlock_kernel();
	return 0;
bail3:
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	iput(result);
bail2:
	hpfs_brelse4(&qbh0);
	hpfs_free_dnode(dir->i_sb, dno);
bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
bail:
	unlock_kernel();
	return err;
}

static int hpfs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
{
	const unsigned char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct inode *result = NULL;
	struct buffer_head *bh;
	struct fnode *fnode;
	fnode_secno fno;
	int r;
	struct hpfs_dirent dee;
	int err;
	if ((err = hpfs_chk_name(name, &len)))
		return err==-ENOENT ? -EINVAL : err;
	lock_kernel();
	err = -ENOSPC;
	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	if (!fnode)
		goto bail;
	memset(&dee, 0, sizeof dee);
	if (!(mode & 0222)) dee.read_only = 1;
	dee.archive = 1;
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());

	result = new_inode(dir->i_sb);
	if (!result)
		goto bail1;
	
	hpfs_init_inode(result);
	result->i_ino = fno;
	result->i_mode |= S_IFREG;
	result->i_mode &= ~0111;
	result->i_op = &hpfs_file_iops;
	result->i_fop = &hpfs_file_ops;
	result->i_nlink = 1;
	hpfs_decide_conv(result, name, len);
	hpfs_i(result)->i_parent_dir = dir->i_ino;
	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	result->i_ctime.tv_nsec = 0;
	result->i_mtime.tv_nsec = 0;
	result->i_atime.tv_nsec = 0;
	hpfs_i(result)->i_ea_size = 0;
	if (dee.read_only)
		result->i_mode &= ~0222;
	result->i_blocks = 1;
	result->i_size = 0;
	result->i_data.a_ops = &hpfs_aops;
	hpfs_i(result)->mmu_private = 0;

	mutex_lock(&hpfs_i(dir)->i_mutex);
	r = hpfs_add_dirent(dir, name, len, &dee, 0);
	if (r == 1)
		goto bail2;
	if (r == -1) {
		err = -EEXIST;
		goto bail2;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	mark_buffer_dirty(bh);
	brelse(bh);

	insert_inode_hash(result);

	if (result->i_uid != current_fsuid() ||
	    result->i_gid != current_fsgid() ||
	    result->i_mode != (mode | S_IFREG)) {
		result->i_uid = current_fsuid();
		result->i_gid = current_fsgid();
		result->i_mode = mode | S_IFREG;
		hpfs_write_inode_nolock(result);
	}
	d_instantiate(dentry, result);
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	unlock_kernel();
	return 0;

bail2:
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	iput(result);
bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
bail:
	unlock_kernel();
	return err;
}

static int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
{
	const unsigned char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct buffer_head *bh;
	struct fnode *fnode;
	fnode_secno fno;
	int r;
	struct hpfs_dirent dee;
	struct inode *result = NULL;
	int err;
	if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
	if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
	if (!new_valid_dev(rdev))
		return -EINVAL;
	lock_kernel();
	err = -ENOSPC;
	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	if (!fnode)
		goto bail;
	memset(&dee, 0, sizeof dee);
	if (!(mode & 0222)) dee.read_only = 1;
	dee.archive = 1;
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());

	result = new_inode(dir->i_sb);
	if (!result)
		goto bail1;

	hpfs_init_inode(result);
	result->i_ino = fno;
	hpfs_i(result)->i_parent_dir = dir->i_ino;
	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	result->i_ctime.tv_nsec = 0;
	result->i_mtime.tv_nsec = 0;
	result->i_atime.tv_nsec = 0;
	hpfs_i(result)->i_ea_size = 0;
	result->i_uid = current_fsuid();
	result->i_gid = current_fsgid();
	result->i_nlink = 1;
	result->i_size = 0;
	result->i_blocks = 1;
	init_special_inode(result, mode, rdev);

	mutex_lock(&hpfs_i(dir)->i_mutex);
	r = hpfs_add_dirent(dir, name, len, &dee, 0);
	if (r == 1)
		goto bail2;
	if (r == -1) {
		err = -EEXIST;
		goto bail2;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	mark_buffer_dirty(bh);

	insert_inode_hash(result);

	hpfs_write_inode_nolock(result);
	d_instantiate(dentry, result);
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	brelse(bh);
	unlock_kernel();
	return 0;
bail2:
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	iput(result);
bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
bail:
	unlock_kernel();
	return err;
}

static int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
{
	const unsigned char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct buffer_head *bh;
	struct fnode *fnode;
	fnode_secno fno;
	int r;
	struct hpfs_dirent dee;
	struct inode *result;
	int err;
	if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
	lock_kernel();
	if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
		unlock_kernel();
		return -EPERM;
	}
	err = -ENOSPC;
	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	if (!fnode)
		goto bail;
	memset(&dee, 0, sizeof dee);
	dee.archive = 1;
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());

	result = new_inode(dir->i_sb);
	if (!result)
		goto bail1;
	result->i_ino = fno;
	hpfs_init_inode(result);
	hpfs_i(result)->i_parent_dir = dir->i_ino;
	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	result->i_ctime.tv_nsec = 0;
	result->i_mtime.tv_nsec = 0;
	result->i_atime.tv_nsec = 0;
	hpfs_i(result)->i_ea_size = 0;
	result->i_mode = S_IFLNK | 0777;
	result->i_uid = current_fsuid();
	result->i_gid = current_fsgid();
	result->i_blocks = 1;
	result->i_nlink = 1;
	result->i_size = strlen(symlink);
	result->i_op = &page_symlink_inode_operations;
	result->i_data.a_ops = &hpfs_symlink_aops;

	mutex_lock(&hpfs_i(dir)->i_mutex);
	r = hpfs_add_dirent(dir, name, len, &dee, 0);
	if (r == 1)
		goto bail2;
	if (r == -1) {
		err = -EEXIST;
		goto bail2;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
	mark_buffer_dirty(bh);
	brelse(bh);

	insert_inode_hash(result);

	hpfs_write_inode_nolock(result);
	d_instantiate(dentry, result);
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	unlock_kernel();
	return 0;
bail2:
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	iput(result);
bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
bail:
	unlock_kernel();
	return err;
}

static int hpfs_unlink(struct inode *dir, struct dentry *dentry)
{
	const unsigned char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct quad_buffer_head qbh;
	struct hpfs_dirent *de;
	struct inode *inode = dentry->d_inode;
	dnode_secno dno;
	fnode_secno fno;
	int r;
	int rep = 0;
	int err;

	lock_kernel();
	hpfs_adjust_length(name, &len);
again:
	mutex_lock(&hpfs_i(inode)->i_parent_mutex);
	mutex_lock(&hpfs_i(dir)->i_mutex);
	err = -ENOENT;
	de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
	if (!de)
		goto out;

	err = -EPERM;
	if (de->first)
		goto out1;

	err = -EISDIR;
	if (de->directory)
		goto out1;

	fno = de->fnode;
	r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
	switch (r) {
	case 1:
		hpfs_error(dir->i_sb, "there was error when removing dirent");
		err = -EFSERROR;
		break;
	case 2:		/* no space for deleting, try to truncate file */

		err = -ENOSPC;
		if (rep++)
			break;

		mutex_unlock(&hpfs_i(dir)->i_mutex);
		mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
		dentry_unhash(dentry);
		if (!d_unhashed(dentry)) {
			dput(dentry);
			unlock_kernel();
			return -ENOSPC;
		}
		if (generic_permission(inode, MAY_WRITE, NULL) ||
		    !S_ISREG(inode->i_mode) ||
		    get_write_access(inode)) {
			d_rehash(dentry);
			dput(dentry);
		} else {
			struct iattr newattrs;
			/*printk("HPFS: truncating file before delete.\n");*/
			newattrs.ia_size = 0;
			newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
			err = notify_change(dentry, &newattrs);
			put_write_access(inode);
			dput(dentry);
			if (!err)
				goto again;
		}
		unlock_kernel();
		return -ENOSPC;
	default:
		drop_nlink(inode);
		err = 0;
	}
	goto out;

out1:
	hpfs_brelse4(&qbh);
out:
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
	unlock_kernel();
	return err;
}

static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	const unsigned char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct quad_buffer_head qbh;
	struct hpfs_dirent *de;
	struct inode *inode = dentry->d_inode;
	dnode_secno dno;
	fnode_secno fno;
	int n_items = 0;
	int err;
	int r;

	hpfs_adjust_length(name, &len);
	lock_kernel();
	mutex_lock(&hpfs_i(inode)->i_parent_mutex);
	mutex_lock(&hpfs_i(dir)->i_mutex);
	err = -ENOENT;
	de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
	if (!de)
		goto out;

	err = -EPERM;
	if (de->first)
		goto out1;

	err = -ENOTDIR;
	if (!de->directory)
		goto out1;

	hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
	err = -ENOTEMPTY;
	if (n_items)
		goto out1;

	fno = de->fnode;
	r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
	switch (r) {
	case 1:
		hpfs_error(dir->i_sb, "there was error when removing dirent");
		err = -EFSERROR;
		break;
	case 2:
		err = -ENOSPC;
		break;
	default:
		drop_nlink(dir);
		clear_nlink(inode);
		err = 0;
	}
	goto out;
out1:
	hpfs_brelse4(&qbh);
out:
	mutex_unlock(&hpfs_i(dir)->i_mutex);
	mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
	unlock_kernel();
	return err;
}

static int hpfs_symlink_readpage(struct file *file, struct page *page)
{
	char *link = kmap(page);
	struct inode *i = page->mapping->host;
	struct fnode *fnode;
	struct buffer_head *bh;
	int err;

	err = -EIO;
	lock_kernel();
	if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
		goto fail;
	err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
	brelse(bh);
	if (err)
		goto fail;
	unlock_kernel();
	SetPageUptodate(page);
	kunmap(page);
	unlock_page(page);
	return 0;

fail:
	unlock_kernel();
	SetPageError(page);
	kunmap(page);
	unlock_page(page);
	return err;
}

const struct address_space_operations hpfs_symlink_aops = {
	.readpage	= hpfs_symlink_readpage
};
	
static int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
		struct inode *new_dir, struct dentry *new_dentry)
{
	const unsigned char *old_name = old_dentry->d_name.name;
	unsigned old_len = old_dentry->d_name.len;
	const unsigned char *new_name = new_dentry->d_name.name;
	unsigned new_len = new_dentry->d_name.len;
	struct inode *i = old_dentry->d_inode;
	struct inode *new_inode = new_dentry->d_inode;
	struct quad_buffer_head qbh, qbh1;
	struct hpfs_dirent *dep, *nde;
	struct hpfs_dirent de;
	dnode_secno dno;
	int r;
	struct buffer_head *bh;
	struct fnode *fnode;
	int err;
	if ((err = hpfs_chk_name(new_name, &new_len))) return err;
	err = 0;
	hpfs_adjust_length(old_name, &old_len);

	lock_kernel();
	/* order doesn't matter, due to VFS exclusion */
	mutex_lock(&hpfs_i(i)->i_parent_mutex);
	if (new_inode)
		mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
	mutex_lock(&hpfs_i(old_dir)->i_mutex);
	if (new_dir != old_dir)
		mutex_lock(&hpfs_i(new_dir)->i_mutex);
	
	/* Erm? Moving over the empty non-busy directory is perfectly legal */
	if (new_inode && S_ISDIR(new_inode->i_mode)) {
		err = -EINVAL;
		goto end1;
	}

	if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
		hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
		err = -ENOENT;
		goto end1;
	}
	copy_de(&de, dep);
	de.hidden = new_name[0] == '.';

	if (new_inode) {
		int r;
		if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
			if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) {
				clear_nlink(new_inode);
				copy_de(nde, &de);
				memcpy(nde->name, new_name, new_len);
				hpfs_mark_4buffers_dirty(&qbh1);
				hpfs_brelse4(&qbh1);
				goto end;
			}
			hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
			err = -EFSERROR;
			goto end1;
		}
		err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
		goto end1;
	}

	if (new_dir == old_dir) hpfs_brelse4(&qbh);

	hpfs_lock_creation(i->i_sb);
	if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
		hpfs_unlock_creation(i->i_sb);
		if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
		err = r == 1 ? -ENOSPC : -EFSERROR;
		if (new_dir != old_dir) hpfs_brelse4(&qbh);
		goto end1;
	}
	
	if (new_dir == old_dir)
		if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
			hpfs_unlock_creation(i->i_sb);
			hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
			err = -ENOENT;
			goto end1;
		}

	if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
		hpfs_unlock_creation(i->i_sb);
		hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
		err = r == 2 ? -ENOSPC : -EFSERROR;
		goto end1;
	}
	hpfs_unlock_creation(i->i_sb);
	
	end:
	hpfs_i(i)->i_parent_dir = new_dir->i_ino;
	if (S_ISDIR(i->i_mode)) {
		inc_nlink(new_dir);
		drop_nlink(old_dir);
	}
	if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
		fnode->up = new_dir->i_ino;
		fnode->len = new_len;
		memcpy(fnode->name, new_name, new_len>15?15:new_len);
		if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
		mark_buffer_dirty(bh);
		brelse(bh);
	}
	hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
	hpfs_decide_conv(i, new_name, new_len);
end1:
	if (old_dir != new_dir)
		mutex_unlock(&hpfs_i(new_dir)->i_mutex);
	mutex_unlock(&hpfs_i(old_dir)->i_mutex);
	mutex_unlock(&hpfs_i(i)->i_parent_mutex);
	if (new_inode)
		mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
	unlock_kernel();
	return err;
}

const struct inode_operations hpfs_dir_iops =
{
	.create		= hpfs_create,
	.lookup		= hpfs_lookup,
	.unlink		= hpfs_unlink,
	.symlink	= hpfs_symlink,
	.mkdir		= hpfs_mkdir,
	.rmdir		= hpfs_rmdir,
	.mknod		= hpfs_mknod,
	.rename		= hpfs_rename,
	.setattr	= hpfs_setattr,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hpfs/namei.c
	3	*
	4	* Mikulas Patocka ([email protected]), 1998-1999
	5	*
	6	* adding & removing files & directories
	7	*/
e8edc6e0	8	#include <linux/sched.h>
405f5571	9	#include <linux/smp_lock.h>
1da177e4 LT	10	#include "hpfs_fn.h"
	11
	12	static int hpfs_mkdir(struct inode dir, struct dentry dentry, int mode)
	13	{
7e7742ee	14	const unsigned char *name = dentry->d_name.name;
1da177e4 LT	15	unsigned len = dentry->d_name.len;
	16	struct quad_buffer_head qbh0;
	17	struct buffer_head *bh;
	18	struct hpfs_dirent *de;
	19	struct fnode *fnode;
	20	struct dnode *dnode;
	21	struct inode *result;
	22	fnode_secno fno;
	23	dnode_secno dno;
	24	int r;
	25	struct hpfs_dirent dee;
	26	int err;
7e7742ee	27	if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
1da177e4 LT	28	lock_kernel();
	29	err = -ENOSPC;
	30	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	31	if (!fnode)
	32	goto bail;
	33	dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
	34	if (!dnode)
	35	goto bail1;
	36	memset(&dee, 0, sizeof dee);
	37	dee.directory = 1;
	38	if (!(mode & 0222)) dee.read_only = 1;
	39	/dee.archive = 0;/
	40	dee.hidden = name[0] == '.';
	41	dee.fnode = fno;
	42	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
	43	result = new_inode(dir->i_sb);
	44	if (!result)
	45	goto bail2;
	46	hpfs_init_inode(result);
	47	result->i_ino = fno;
	48	hpfs_i(result)->i_parent_dir = dir->i_ino;
	49	hpfs_i(result)->i_dno = dno;
	50	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	51	result->i_ctime.tv_nsec = 0;
	52	result->i_mtime.tv_nsec = 0;
	53	result->i_atime.tv_nsec = 0;
	54	hpfs_i(result)->i_ea_size = 0;
	55	result->i_mode \|= S_IFDIR;
	56	result->i_op = &hpfs_dir_iops;
	57	result->i_fop = &hpfs_dir_ops;
	58	result->i_blocks = 4;
	59	result->i_size = 2048;
	60	result->i_nlink = 2;
	61	if (dee.read_only)
	62	result->i_mode &= ~0222;
	63
7bf6d78d	64	mutex_lock(&hpfs_i(dir)->i_mutex);
7e7742ee	65	r = hpfs_add_dirent(dir, name, len, &dee, 0);
1da177e4 LT	66	if (r == 1)
	67	goto bail3;
	68	if (r == -1) {
	69	err = -EEXIST;
	70	goto bail3;
	71	}
	72	fnode->len = len;
	73	memcpy(fnode->name, name, len > 15 ? 15 : len);
	74	fnode->up = dir->i_ino;
	75	fnode->dirflag = 1;
	76	fnode->btree.n_free_nodes = 7;
	77	fnode->btree.n_used_nodes = 1;
	78	fnode->btree.first_free = 0x14;
	79	fnode->u.external[0].disk_secno = dno;
	80	fnode->u.external[0].file_secno = -1;
	81	dnode->root_dnode = 1;
	82	dnode->up = fno;
	83	de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
	84	de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
	85	if (!(mode & 0222)) de->read_only = 1;
	86	de->first = de->directory = 1;
	87	/de->hidden = de->system = 0;/
	88	de->fnode = fno;
	89	mark_buffer_dirty(bh);
	90	brelse(bh);
	91	hpfs_mark_4buffers_dirty(&qbh0);
	92	hpfs_brelse4(&qbh0);
d8c76e6f	93	inc_nlink(dir);
1da177e4 LT	94	insert_inode_hash(result);
1da177e4 LT	95
de395b8a DH	96	if (result->i_uid != current_fsuid() \|\|
de395b8a DH	97	result->i_gid != current_fsgid() \|\|
1da177e4	98	result->i_mode != (mode \| S_IFDIR)) {
de395b8a DH	99	result->i_uid = current_fsuid();
de395b8a DH	100	result->i_gid = current_fsgid();
1da177e4 LT	101	result->i_mode = mode \| S_IFDIR;
	102	hpfs_write_inode_nolock(result);
	103	}
	104	d_instantiate(dentry, result);
7bf6d78d	105	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	106	unlock_kernel();
	107	return 0;
	108	bail3:
7bf6d78d	109	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	110	iput(result);
	111	bail2:
	112	hpfs_brelse4(&qbh0);
	113	hpfs_free_dnode(dir->i_sb, dno);
	114	bail1:
	115	brelse(bh);
	116	hpfs_free_sectors(dir->i_sb, fno, 1);
	117	bail:
	118	unlock_kernel();
	119	return err;
	120	}
	121
	122	static int hpfs_create(struct inode dir, struct dentry dentry, int mode, struct nameidata *nd)
	123	{
7e7742ee	124	const unsigned char *name = dentry->d_name.name;
1da177e4 LT	125	unsigned len = dentry->d_name.len;
	126	struct inode *result = NULL;
	127	struct buffer_head *bh;
	128	struct fnode *fnode;
	129	fnode_secno fno;
	130	int r;
	131	struct hpfs_dirent dee;
	132	int err;
7e7742ee	133	if ((err = hpfs_chk_name(name, &len)))
1da177e4 LT	134	return err==-ENOENT ? -EINVAL : err;
	135	lock_kernel();
	136	err = -ENOSPC;
	137	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	138	if (!fnode)
	139	goto bail;
	140	memset(&dee, 0, sizeof dee);
	141	if (!(mode & 0222)) dee.read_only = 1;
	142	dee.archive = 1;
	143	dee.hidden = name[0] == '.';
	144	dee.fnode = fno;
	145	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
	146
	147	result = new_inode(dir->i_sb);
	148	if (!result)
	149	goto bail1;
	150
	151	hpfs_init_inode(result);
	152	result->i_ino = fno;
	153	result->i_mode \|= S_IFREG;
	154	result->i_mode &= ~0111;
	155	result->i_op = &hpfs_file_iops;
	156	result->i_fop = &hpfs_file_ops;
	157	result->i_nlink = 1;
7e7742ee	158	hpfs_decide_conv(result, name, len);
1da177e4 LT	159	hpfs_i(result)->i_parent_dir = dir->i_ino;
	160	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	161	result->i_ctime.tv_nsec = 0;
	162	result->i_mtime.tv_nsec = 0;
	163	result->i_atime.tv_nsec = 0;
	164	hpfs_i(result)->i_ea_size = 0;
	165	if (dee.read_only)
	166	result->i_mode &= ~0222;
	167	result->i_blocks = 1;
	168	result->i_size = 0;
	169	result->i_data.a_ops = &hpfs_aops;
	170	hpfs_i(result)->mmu_private = 0;
	171
7bf6d78d	172	mutex_lock(&hpfs_i(dir)->i_mutex);
7e7742ee	173	r = hpfs_add_dirent(dir, name, len, &dee, 0);
1da177e4 LT	174	if (r == 1)
	175	goto bail2;
	176	if (r == -1) {
	177	err = -EEXIST;
	178	goto bail2;
	179	}
	180	fnode->len = len;
	181	memcpy(fnode->name, name, len > 15 ? 15 : len);
	182	fnode->up = dir->i_ino;
	183	mark_buffer_dirty(bh);
	184	brelse(bh);
	185
	186	insert_inode_hash(result);
	187
de395b8a DH	188	if (result->i_uid != current_fsuid() \|\|
de395b8a DH	189	result->i_gid != current_fsgid() \|\|
1da177e4	190	result->i_mode != (mode \| S_IFREG)) {
de395b8a DH	191	result->i_uid = current_fsuid();
de395b8a DH	192	result->i_gid = current_fsgid();
1da177e4 LT	193	result->i_mode = mode \| S_IFREG;
	194	hpfs_write_inode_nolock(result);
	195	}
	196	d_instantiate(dentry, result);
7bf6d78d	197	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	198	unlock_kernel();
	199	return 0;
	200
	201	bail2:
7bf6d78d	202	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	203	iput(result);
	204	bail1:
	205	brelse(bh);
	206	hpfs_free_sectors(dir->i_sb, fno, 1);
	207	bail:
	208	unlock_kernel();
	209	return err;
	210	}
	211
	212	static int hpfs_mknod(struct inode dir, struct dentry dentry, int mode, dev_t rdev)
	213	{
7e7742ee	214	const unsigned char *name = dentry->d_name.name;
1da177e4 LT	215	unsigned len = dentry->d_name.len;
	216	struct buffer_head *bh;
	217	struct fnode *fnode;
	218	fnode_secno fno;
	219	int r;
	220	struct hpfs_dirent dee;
	221	struct inode *result = NULL;
	222	int err;
7e7742ee	223	if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
1da177e4 LT	224	if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM;
	225	if (!new_valid_dev(rdev))
	226	return -EINVAL;
	227	lock_kernel();
	228	err = -ENOSPC;
	229	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	230	if (!fnode)
	231	goto bail;
	232	memset(&dee, 0, sizeof dee);
	233	if (!(mode & 0222)) dee.read_only = 1;
	234	dee.archive = 1;
	235	dee.hidden = name[0] == '.';
	236	dee.fnode = fno;
	237	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
	238
	239	result = new_inode(dir->i_sb);
	240	if (!result)
	241	goto bail1;
	242
	243	hpfs_init_inode(result);
	244	result->i_ino = fno;
	245	hpfs_i(result)->i_parent_dir = dir->i_ino;
	246	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	247	result->i_ctime.tv_nsec = 0;
	248	result->i_mtime.tv_nsec = 0;
	249	result->i_atime.tv_nsec = 0;
	250	hpfs_i(result)->i_ea_size = 0;
de395b8a DH	251	result->i_uid = current_fsuid();
de395b8a DH	252	result->i_gid = current_fsgid();
1da177e4 LT	253	result->i_nlink = 1;
	254	result->i_size = 0;
	255	result->i_blocks = 1;
	256	init_special_inode(result, mode, rdev);
	257
7bf6d78d	258	mutex_lock(&hpfs_i(dir)->i_mutex);
7e7742ee	259	r = hpfs_add_dirent(dir, name, len, &dee, 0);
1da177e4 LT	260	if (r == 1)
	261	goto bail2;
	262	if (r == -1) {
	263	err = -EEXIST;
	264	goto bail2;
	265	}
	266	fnode->len = len;
	267	memcpy(fnode->name, name, len > 15 ? 15 : len);
	268	fnode->up = dir->i_ino;
	269	mark_buffer_dirty(bh);
	270
	271	insert_inode_hash(result);
	272
	273	hpfs_write_inode_nolock(result);
	274	d_instantiate(dentry, result);
7bf6d78d	275	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	276	brelse(bh);
	277	unlock_kernel();
	278	return 0;
	279	bail2:
7bf6d78d	280	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	281	iput(result);
	282	bail1:
	283	brelse(bh);
	284	hpfs_free_sectors(dir->i_sb, fno, 1);
	285	bail:
	286	unlock_kernel();
	287	return err;
	288	}
	289
	290	static int hpfs_symlink(struct inode dir, struct dentry dentry, const char *symlink)
	291	{
7e7742ee	292	const unsigned char *name = dentry->d_name.name;
1da177e4 LT	293	unsigned len = dentry->d_name.len;
	294	struct buffer_head *bh;
	295	struct fnode *fnode;
	296	fnode_secno fno;
	297	int r;
	298	struct hpfs_dirent dee;
	299	struct inode *result;
	300	int err;
7e7742ee	301	if ((err = hpfs_chk_name(name, &len))) return err==-ENOENT ? -EINVAL : err;
1da177e4 LT	302	lock_kernel();
	303	if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
	304	unlock_kernel();
	305	return -EPERM;
	306	}
	307	err = -ENOSPC;
	308	fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
	309	if (!fnode)
	310	goto bail;
	311	memset(&dee, 0, sizeof dee);
	312	dee.archive = 1;
	313	dee.hidden = name[0] == '.';
	314	dee.fnode = fno;
	315	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
	316
	317	result = new_inode(dir->i_sb);
	318	if (!result)
	319	goto bail1;
	320	result->i_ino = fno;
	321	hpfs_init_inode(result);
	322	hpfs_i(result)->i_parent_dir = dir->i_ino;
	323	result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
	324	result->i_ctime.tv_nsec = 0;
	325	result->i_mtime.tv_nsec = 0;
	326	result->i_atime.tv_nsec = 0;
	327	hpfs_i(result)->i_ea_size = 0;
	328	result->i_mode = S_IFLNK \| 0777;
de395b8a DH	329	result->i_uid = current_fsuid();
de395b8a DH	330	result->i_gid = current_fsgid();
1da177e4 LT	331	result->i_blocks = 1;
	332	result->i_nlink = 1;
	333	result->i_size = strlen(symlink);
	334	result->i_op = &page_symlink_inode_operations;
	335	result->i_data.a_ops = &hpfs_symlink_aops;
	336
7bf6d78d	337	mutex_lock(&hpfs_i(dir)->i_mutex);
7e7742ee	338	r = hpfs_add_dirent(dir, name, len, &dee, 0);
1da177e4 LT	339	if (r == 1)
	340	goto bail2;
	341	if (r == -1) {
	342	err = -EEXIST;
	343	goto bail2;
	344	}
	345	fnode->len = len;
	346	memcpy(fnode->name, name, len > 15 ? 15 : len);
	347	fnode->up = dir->i_ino;
7e7742ee	348	hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
1da177e4 LT	349	mark_buffer_dirty(bh);
	350	brelse(bh);
	351
	352	insert_inode_hash(result);
	353
	354	hpfs_write_inode_nolock(result);
	355	d_instantiate(dentry, result);
7bf6d78d	356	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	357	unlock_kernel();
	358	return 0;
	359	bail2:
7bf6d78d	360	mutex_unlock(&hpfs_i(dir)->i_mutex);
1da177e4 LT	361	iput(result);
	362	bail1:
	363	brelse(bh);
	364	hpfs_free_sectors(dir->i_sb, fno, 1);
	365	bail:
	366	unlock_kernel();
	367	return err;
	368	}
	369
	370	static int hpfs_unlink(struct inode dir, struct dentry dentry)
	371	{
7e7742ee	372	const unsigned char *name = dentry->d_name.name;
1da177e4 LT	373	unsigned len = dentry->d_name.len;
	374	struct quad_buffer_head qbh;
	375	struct hpfs_dirent *de;
	376	struct inode *inode = dentry->d_inode;
	377	dnode_secno dno;
	378	fnode_secno fno;
	379	int r;
	380	int rep = 0;
	381	int err;
	382
	383	lock_kernel();
7e7742ee	384	hpfs_adjust_length(name, &len);
1da177e4	385	again:
7bf6d78d IM	386	mutex_lock(&hpfs_i(inode)->i_parent_mutex);
7bf6d78d IM	387	mutex_lock(&hpfs_i(dir)->i_mutex);
1da177e4	388	err = -ENOENT;
7e7742ee	389	de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
1da177e4 LT	390	if (!de)
	391	goto out;
	392
	393	err = -EPERM;
	394	if (de->first)
	395	goto out1;
	396
	397	err = -EISDIR;
	398	if (de->directory)
	399	goto out1;
	400
	401	fno = de->fnode;
	402	r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
	403	switch (r) {
	404	case 1:
	405	hpfs_error(dir->i_sb, "there was error when removing dirent");
	406	err = -EFSERROR;
	407	break;
	408	case 2: /* no space for deleting, try to truncate file */
	409
	410	err = -ENOSPC;
	411	if (rep++)
	412	break;
	413
7bf6d78d IM	414	mutex_unlock(&hpfs_i(dir)->i_mutex);
7bf6d78d IM	415	mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
e21e7095 AV	416	dentry_unhash(dentry);
	417	if (!d_unhashed(dentry)) {
	418	dput(dentry);
	419	unlock_kernel();
	420	return -ENOSPC;
	421	}
	422	if (generic_permission(inode, MAY_WRITE, NULL) \|\|
1da177e4 LT	423	!S_ISREG(inode->i_mode) \|\|
1da177e4 LT	424	get_write_access(inode)) {
1da177e4	425	d_rehash(dentry);
e21e7095	426	dput(dentry);
1da177e4 LT	427	} else {
1da177e4 LT	428	struct iattr newattrs;
1da177e4 LT	429	/printk("HPFS: truncating file before delete.\n");/
	430	newattrs.ia_size = 0;
	431	newattrs.ia_valid = ATTR_SIZE \| ATTR_CTIME;
	432	err = notify_change(dentry, &newattrs);
	433	put_write_access(inode);
e21e7095	434	dput(dentry);
1da177e4 LT	435	if (!err)
	436	goto again;
	437	}
	438	unlock_kernel();
	439	return -ENOSPC;
	440	default:
9a53c3a7	441	drop_nlink(inode);
1da177e4 LT	442	err = 0;
	443	}
	444	goto out;
	445
	446	out1:
	447	hpfs_brelse4(&qbh);
	448	out:
7bf6d78d IM	449	mutex_unlock(&hpfs_i(dir)->i_mutex);
7bf6d78d IM	450	mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
1da177e4 LT	451	unlock_kernel();
	452	return err;
	453	}
	454
	455	static int hpfs_rmdir(struct inode dir, struct dentry dentry)
	456	{
7e7742ee	457	const unsigned char *name = dentry->d_name.name;
1da177e4 LT	458	unsigned len = dentry->d_name.len;
	459	struct quad_buffer_head qbh;
	460	struct hpfs_dirent *de;
	461	struct inode *inode = dentry->d_inode;
	462	dnode_secno dno;
	463	fnode_secno fno;
	464	int n_items = 0;
	465	int err;
	466	int r;
	467
7e7742ee	468	hpfs_adjust_length(name, &len);
1da177e4	469	lock_kernel();
7bf6d78d IM	470	mutex_lock(&hpfs_i(inode)->i_parent_mutex);
7bf6d78d IM	471	mutex_lock(&hpfs_i(dir)->i_mutex);
1da177e4	472	err = -ENOENT;
7e7742ee	473	de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
1da177e4 LT	474	if (!de)
	475	goto out;
	476
	477	err = -EPERM;
	478	if (de->first)
	479	goto out1;
	480
	481	err = -ENOTDIR;
	482	if (!de->directory)
	483	goto out1;
	484
	485	hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items);
	486	err = -ENOTEMPTY;
	487	if (n_items)
	488	goto out1;
	489
	490	fno = de->fnode;
	491	r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
	492	switch (r) {
	493	case 1:
	494	hpfs_error(dir->i_sb, "there was error when removing dirent");
	495	err = -EFSERROR;
	496	break;
	497	case 2:
	498	err = -ENOSPC;
	499	break;
	500	default:
9a53c3a7	501	drop_nlink(dir);
ce71ec36	502	clear_nlink(inode);
1da177e4 LT	503	err = 0;
	504	}
	505	goto out;
	506	out1:
	507	hpfs_brelse4(&qbh);
	508	out:
7bf6d78d IM	509	mutex_unlock(&hpfs_i(dir)->i_mutex);
7bf6d78d IM	510	mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
1da177e4 LT	511	unlock_kernel();
	512	return err;
	513	}
	514
	515	static int hpfs_symlink_readpage(struct file file, struct page page)
	516	{
	517	char *link = kmap(page);
	518	struct inode *i = page->mapping->host;
	519	struct fnode *fnode;
	520	struct buffer_head *bh;
	521	int err;
	522
	523	err = -EIO;
	524	lock_kernel();
	525	if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh)))
	526	goto fail;
	527	err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
	528	brelse(bh);
	529	if (err)
	530	goto fail;
	531	unlock_kernel();
	532	SetPageUptodate(page);
	533	kunmap(page);
	534	unlock_page(page);
	535	return 0;
	536
	537	fail:
	538	unlock_kernel();
	539	SetPageError(page);
	540	kunmap(page);
	541	unlock_page(page);
	542	return err;
	543	}
	544
f5e54d6e	545	const struct address_space_operations hpfs_symlink_aops = {
1da177e4 LT	546	.readpage = hpfs_symlink_readpage
	547	};
	548
	549	static int hpfs_rename(struct inode old_dir, struct dentry old_dentry,
	550	struct inode new_dir, struct dentry new_dentry)
	551	{
7e7742ee AV	552	const unsigned char *old_name = old_dentry->d_name.name;
	553	unsigned old_len = old_dentry->d_name.len;
	554	const unsigned char *new_name = new_dentry->d_name.name;
	555	unsigned new_len = new_dentry->d_name.len;
1da177e4 LT	556	struct inode *i = old_dentry->d_inode;
	557	struct inode *new_inode = new_dentry->d_inode;
	558	struct quad_buffer_head qbh, qbh1;
	559	struct hpfs_dirent dep, nde;
	560	struct hpfs_dirent de;
	561	dnode_secno dno;
	562	int r;
	563	struct buffer_head *bh;
	564	struct fnode *fnode;
	565	int err;
7e7742ee	566	if ((err = hpfs_chk_name(new_name, &new_len))) return err;
1da177e4	567	err = 0;
7e7742ee	568	hpfs_adjust_length(old_name, &old_len);
1da177e4 LT	569
	570	lock_kernel();
	571	/* order doesn't matter, due to VFS exclusion */
7bf6d78d	572	mutex_lock(&hpfs_i(i)->i_parent_mutex);
1da177e4	573	if (new_inode)
7bf6d78d IM	574	mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
7bf6d78d IM	575	mutex_lock(&hpfs_i(old_dir)->i_mutex);
1da177e4	576	if (new_dir != old_dir)
7bf6d78d	577	mutex_lock(&hpfs_i(new_dir)->i_mutex);
1da177e4 LT	578
	579	/* Erm? Moving over the empty non-busy directory is perfectly legal */
	580	if (new_inode && S_ISDIR(new_inode->i_mode)) {
	581	err = -EINVAL;
	582	goto end1;
	583	}
	584
7e7742ee	585	if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
1da177e4 LT	586	hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
	587	err = -ENOENT;
	588	goto end1;
	589	}
	590	copy_de(&de, dep);
	591	de.hidden = new_name[0] == '.';
	592
	593	if (new_inode) {
	594	int r;
	595	if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
7e7742ee	596	if ((nde = map_dirent(new_dir, hpfs_i(new_dir)->i_dno, new_name, new_len, NULL, &qbh1))) {
ce71ec36	597	clear_nlink(new_inode);
1da177e4 LT	598	copy_de(nde, &de);
	599	memcpy(nde->name, new_name, new_len);
	600	hpfs_mark_4buffers_dirty(&qbh1);
	601	hpfs_brelse4(&qbh1);
	602	goto end;
	603	}
	604	hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
	605	err = -EFSERROR;
	606	goto end1;
	607	}
	608	err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
	609	goto end1;
	610	}
	611
	612	if (new_dir == old_dir) hpfs_brelse4(&qbh);
	613
	614	hpfs_lock_creation(i->i_sb);
	615	if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
	616	hpfs_unlock_creation(i->i_sb);
	617	if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
	618	err = r == 1 ? -ENOSPC : -EFSERROR;
	619	if (new_dir != old_dir) hpfs_brelse4(&qbh);
	620	goto end1;
	621	}
	622
	623	if (new_dir == old_dir)
7e7742ee	624	if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
1da177e4 LT	625	hpfs_unlock_creation(i->i_sb);
	626	hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
	627	err = -ENOENT;
	628	goto end1;
	629	}
	630
	631	if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
	632	hpfs_unlock_creation(i->i_sb);
	633	hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
	634	err = r == 2 ? -ENOSPC : -EFSERROR;
	635	goto end1;
	636	}
	637	hpfs_unlock_creation(i->i_sb);
	638
	639	end:
	640	hpfs_i(i)->i_parent_dir = new_dir->i_ino;
	641	if (S_ISDIR(i->i_mode)) {
d8c76e6f	642	inc_nlink(new_dir);
9a53c3a7	643	drop_nlink(old_dir);
1da177e4 LT	644	}
	645	if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
	646	fnode->up = new_dir->i_ino;
	647	fnode->len = new_len;
	648	memcpy(fnode->name, new_name, new_len>15?15:new_len);
	649	if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
	650	mark_buffer_dirty(bh);
	651	brelse(bh);
	652	}
	653	hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
7e7742ee	654	hpfs_decide_conv(i, new_name, new_len);
1da177e4 LT	655	end1:
1da177e4 LT	656	if (old_dir != new_dir)
7bf6d78d IM	657	mutex_unlock(&hpfs_i(new_dir)->i_mutex);
	658	mutex_unlock(&hpfs_i(old_dir)->i_mutex);
	659	mutex_unlock(&hpfs_i(i)->i_parent_mutex);
1da177e4	660	if (new_inode)
7bf6d78d	661	mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
1da177e4 LT	662	unlock_kernel();
	663	return err;
	664	}
	665
92e1d5be	666	const struct inode_operations hpfs_dir_iops =
1da177e4 LT	667	{
	668	.create = hpfs_create,
	669	.lookup = hpfs_lookup,
	670	.unlink = hpfs_unlink,
	671	.symlink = hpfs_symlink,
	672	.mkdir = hpfs_mkdir,
	673	.rmdir = hpfs_rmdir,
	674	.mknod = hpfs_mknod,
	675	.rename = hpfs_rename,
ca30bc99	676	.setattr = hpfs_setattr,
1da177e4	677	};