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

/*
 *  linux/fs/hpfs/namei.c
 *
 *  Mikulas Patocka ([email protected]), 1998-1999
 *
 *  adding & removing files & directories
 */

#include "hpfs_fn.h"

static int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	const 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((char *)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;

	down(&hpfs_i(dir)->i_sem);
	r = hpfs_add_dirent(dir, (char *)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);
	dir->i_nlink++;
	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);
	up(&hpfs_i(dir)->i_sem);
	unlock_kernel();
	return 0;
bail3:
	up(&hpfs_i(dir)->i_sem);
	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 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((char *)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, (char *)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;

	down(&hpfs_i(dir)->i_sem);
	r = hpfs_add_dirent(dir, (char *)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);
	up(&hpfs_i(dir)->i_sem);
	unlock_kernel();
	return 0;

bail2:
	up(&hpfs_i(dir)->i_sem);
	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 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((char *)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);

	down(&hpfs_i(dir)->i_sem);
	r = hpfs_add_dirent(dir, (char *)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);
	up(&hpfs_i(dir)->i_sem);
	brelse(bh);
	unlock_kernel();
	return 0;
bail2:
	up(&hpfs_i(dir)->i_sem);
	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 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((char *)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;

	down(&hpfs_i(dir)->i_sem);
	r = hpfs_add_dirent(dir, (char *)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", (char *)symlink, strlen(symlink));
	mark_buffer_dirty(bh);
	brelse(bh);

	insert_inode_hash(result);

	hpfs_write_inode_nolock(result);
	d_instantiate(dentry, result);
	up(&hpfs_i(dir)->i_sem);
	unlock_kernel();
	return 0;
bail2:
	up(&hpfs_i(dir)->i_sem);
	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 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((char *)name, &len);
again:
	down(&hpfs_i(inode)->i_parent);
	down(&hpfs_i(dir)->i_sem);
	err = -ENOENT;
	de = map_dirent(dir, hpfs_i(dir)->i_dno, (char *)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;

		up(&hpfs_i(dir)->i_sem);
		up(&hpfs_i(inode)->i_parent);
		d_drop(dentry);
		spin_lock(&dentry->d_lock);
		if (atomic_read(&dentry->d_count) > 1 ||
		    permission(inode, MAY_WRITE, NULL) ||
		    !S_ISREG(inode->i_mode) ||
		    get_write_access(inode)) {
			spin_unlock(&dentry->d_lock);
			d_rehash(dentry);
		} else {
			struct iattr newattrs;
			spin_unlock(&dentry->d_lock);
			/*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);
			if (!err)
				goto again;
		}
		unlock_kernel();
		return -ENOSPC;
	default:
		inode->i_nlink--;
		err = 0;
	}
	goto out;

out1:
	hpfs_brelse4(&qbh);
out:
	up(&hpfs_i(dir)->i_sem);
	up(&hpfs_i(inode)->i_parent);
	unlock_kernel();
	return err;
}

static int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	const 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((char *)name, &len);
	lock_kernel();
	down(&hpfs_i(inode)->i_parent);
	down(&hpfs_i(dir)->i_sem);
	err = -ENOENT;
	de = map_dirent(dir, hpfs_i(dir)->i_dno, (char *)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:
		dir->i_nlink--;
		inode->i_nlink = 0;
		err = 0;
	}
	goto out;
out1:
	hpfs_brelse4(&qbh);
out:
	up(&hpfs_i(dir)->i_sem);
	up(&hpfs_i(inode)->i_parent);
	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;
}

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)
{
	char *old_name = (char *)old_dentry->d_name.name;
	int old_len = old_dentry->d_name.len;
	char *new_name = (char *)new_dentry->d_name.name;
	int 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((char *)new_name, &new_len))) return err;
	err = 0;
	hpfs_adjust_length((char *)old_name, &old_len);

	lock_kernel();
	/* order doesn't matter, due to VFS exclusion */
	down(&hpfs_i(i)->i_parent);
	if (new_inode)
		down(&hpfs_i(new_inode)->i_parent);
	down(&hpfs_i(old_dir)->i_sem);
	if (new_dir != old_dir)
		down(&hpfs_i(new_dir)->i_sem);
	
	/* 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, (char *)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, (char *)new_name, new_len, NULL, &qbh1))) {
				new_inode->i_nlink = 0;
				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, (char *)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)) {
		new_dir->i_nlink++;
		old_dir->i_nlink--;
	}
	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, (char *)new_name, new_len);
end1:
	if (old_dir != new_dir)
		up(&hpfs_i(new_dir)->i_sem);
	up(&hpfs_i(old_dir)->i_sem);
	up(&hpfs_i(i)->i_parent);
	if (new_inode)
		up(&hpfs_i(new_inode)->i_parent);
	unlock_kernel();
	return err;
}

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