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

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/hpfs/namei.c
 *
 *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
 *
 *  adding & removing files & directories
 */
#include <linux/sched.h>
#include "hpfs_fn.h"

static void hpfs_update_directory_times(struct inode *dir)
{
	time64_t t = local_to_gmt(dir->i_sb, local_get_seconds(dir->i_sb));
	if (t == dir->i_mtime.tv_sec &&
	    t == dir->i_ctime.tv_sec)
		return;
	dir->i_mtime.tv_sec = dir->i_ctime.tv_sec = t;
	dir->i_mtime.tv_nsec = dir->i_ctime.tv_nsec = 0;
	hpfs_write_inode_nolock(dir);
}

static int hpfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
		      struct dentry *dentry, umode_t 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;
	hpfs_lock(dir->i_sb);
	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);
	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 = cpu_to_le32(fno);
	dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb));
	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, le32_to_cpu(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;
	set_nlink(result, 2);
	if (dee.read_only)
		result->i_mode &= ~0222;

	r = hpfs_add_dirent(dir, name, len, &dee);
	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 = cpu_to_le32(dir->i_ino);
	fnode->flags |= FNODE_dir;
	fnode->btree.n_free_nodes = 7;
	fnode->btree.n_used_nodes = 1;
	fnode->btree.first_free = cpu_to_le16(0x14);
	fnode->u.external[0].disk_secno = cpu_to_le32(dno);
	fnode->u.external[0].file_secno = cpu_to_le32(-1);
	dnode->root_dnode = 1;
	dnode->up = cpu_to_le32(fno);
	de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
	de->creation_date = de->write_date = de->read_date = cpu_to_le32(local_get_seconds(dir->i_sb));
	if (!(mode & 0222)) de->read_only = 1;
	de->first = de->directory = 1;
	/*de->hidden = de->system = 0;*/
	de->fnode = cpu_to_le32(fno);
	mark_buffer_dirty(bh);
	brelse(bh);
	hpfs_mark_4buffers_dirty(&qbh0);
	hpfs_brelse4(&qbh0);
	inc_nlink(dir);
	insert_inode_hash(result);

	if (!uid_eq(result->i_uid, current_fsuid()) ||
	    !gid_eq(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);
	}
	hpfs_update_directory_times(dir);
	d_instantiate(dentry, result);
	hpfs_unlock(dir->i_sb);
	return 0;
bail3:
	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:
	hpfs_unlock(dir->i_sb);
	return err;
}

static int hpfs_create(struct mnt_idmap *idmap, struct inode *dir,
		       struct dentry *dentry, umode_t mode, bool excl)
{
	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;
	hpfs_lock(dir->i_sb);
	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 = cpu_to_le32(fno);
	dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb));

	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;
	set_nlink(result, 1);
	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, le32_to_cpu(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;

	r = hpfs_add_dirent(dir, name, len, &dee);
	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 = cpu_to_le32(dir->i_ino);
	mark_buffer_dirty(bh);
	brelse(bh);

	insert_inode_hash(result);

	if (!uid_eq(result->i_uid, current_fsuid()) ||
	    !gid_eq(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);
	}
	hpfs_update_directory_times(dir);
	d_instantiate(dentry, result);
	hpfs_unlock(dir->i_sb);
	return 0;

bail2:
	iput(result);
bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
bail:
	hpfs_unlock(dir->i_sb);
	return err;
}

static int hpfs_mknod(struct mnt_idmap *idmap, struct inode *dir,
		      struct dentry *dentry, umode_t 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;
	hpfs_lock(dir->i_sb);
	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 = cpu_to_le32(fno);
	dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb));

	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, le32_to_cpu(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();
	set_nlink(result, 1);
	result->i_size = 0;
	result->i_blocks = 1;
	init_special_inode(result, mode, rdev);

	r = hpfs_add_dirent(dir, name, len, &dee);
	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 = cpu_to_le32(dir->i_ino);
	mark_buffer_dirty(bh);

	insert_inode_hash(result);

	hpfs_write_inode_nolock(result);
	hpfs_update_directory_times(dir);
	d_instantiate(dentry, result);
	brelse(bh);
	hpfs_unlock(dir->i_sb);
	return 0;
bail2:
	iput(result);
bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
bail:
	hpfs_unlock(dir->i_sb);
	return err;
}

static int hpfs_symlink(struct mnt_idmap *idmap, 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;
	hpfs_lock(dir->i_sb);
	if (hpfs_sb(dir->i_sb)->sb_eas < 2) {
		hpfs_unlock(dir->i_sb);
		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 = cpu_to_le32(fno);
	dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(local_get_seconds(dir->i_sb));

	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, le32_to_cpu(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;
	set_nlink(result, 1);
	result->i_size = strlen(symlink);
	inode_nohighmem(result);
	result->i_op = &page_symlink_inode_operations;
	result->i_data.a_ops = &hpfs_symlink_aops;

	r = hpfs_add_dirent(dir, name, len, &dee);
	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 = cpu_to_le32(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);
	hpfs_update_directory_times(dir);
	d_instantiate(dentry, result);
	hpfs_unlock(dir->i_sb);
	return 0;
bail2:
	iput(result);
bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
bail:
	hpfs_unlock(dir->i_sb);
	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 = d_inode(dentry);
	dnode_secno dno;
	int r;
	int err;

	hpfs_lock(dir->i_sb);
	hpfs_adjust_length(name, &len);

	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;

	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 */
		err = -ENOSPC;
		break;
	default:
		drop_nlink(inode);
		err = 0;
	}
	goto out;

out1:
	hpfs_brelse4(&qbh);
out:
	if (!err)
		hpfs_update_directory_times(dir);
	hpfs_unlock(dir->i_sb);
	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 = d_inode(dentry);
	dnode_secno dno;
	int n_items = 0;
	int err;
	int r;

	hpfs_adjust_length(name, &len);
	hpfs_lock(dir->i_sb);
	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;

	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:
	if (!err)
		hpfs_update_directory_times(dir);
	hpfs_unlock(dir->i_sb);
	return err;
}

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

	err = -EIO;
	hpfs_lock(i->i_sb);
	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;
	hpfs_unlock(i->i_sb);
	SetPageUptodate(page);
	unlock_page(page);
	return 0;

fail:
	hpfs_unlock(i->i_sb);
	SetPageError(page);
	unlock_page(page);
	return err;
}

const struct address_space_operations hpfs_symlink_aops = {
	.read_folio	= hpfs_symlink_read_folio
};

static int hpfs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
		       struct dentry *old_dentry, struct inode *new_dir,
		       struct dentry *new_dentry, unsigned int flags)
{
	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 = d_inode(old_dentry);
	struct inode *new_inode = d_inode(new_dentry);
	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 (flags & ~RENAME_NOREPLACE)
		return -EINVAL;

	if ((err = hpfs_chk_name(new_name, &new_len))) return err;
	err = 0;
	hpfs_adjust_length(old_name, &old_len);

	hpfs_lock(i->i_sb);
	/* order doesn't matter, due to VFS exclusion */
	
	/* 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 = -ENOSPC;
		goto end1;
	}

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

	if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de))) {
		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_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_error(i->i_sb, "hpfs_rename: could not remove dirent");
		err = r == 2 ? -ENOSPC : -EFSERROR;
		goto end1;
	}

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