/*
   *  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 int hpfs_mkdir(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(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, 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->dirflag = 1;
  	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(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 = 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 (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);

  	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 inode *dir, struct dentry *dentry, umode_t 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;

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

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

  	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 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;
  	if (!new_valid_dev(rdev))
  		return -EINVAL;

  	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(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, 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);
  	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 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(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, 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);
  	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);
  	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 = dentry->d_inode;
  	dnode_secno dno;

  	int r;
  	int rep = 0;
  	int err;

  	hpfs_lock(dir->i_sb);

  	hpfs_adjust_length(name, &len);

  again:

  	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, try to truncate file */
  
  		err = -ENOSPC;
  		if (rep++)
  			break;

  		dentry_unhash(dentry);
  		if (!d_unhashed(dentry)) {

  			hpfs_unlock(dir->i_sb);

  			return -ENOSPC;
  		}

  		if (generic_permission(inode, MAY_WRITE) ||

  		    !S_ISREG(inode->i_mode) ||
  		    get_write_access(inode)) {

  			d_rehash(dentry);
  		} else {
  			struct iattr newattrs;

  			/*printk("HPFS: truncating file before delete.
  ");*/
  			newattrs.ia_size = 0;
  			newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
  			err = notify_change(dentry, &newattrs);
  			put_write_access(inode);
  			if (!err)
  				goto again;
  		}

  		hpfs_unlock(dir->i_sb);

  		return -ENOSPC;
  	default:

  		drop_nlink(inode);

  		err = 0;
  	}
  	goto out;
  
  out1:
  	hpfs_brelse4(&qbh);
  out:

  	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 = dentry->d_inode;
  	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:

  	hpfs_unlock(dir->i_sb);

  	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;

  	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);
  	kunmap(page);
  	unlock_page(page);
  	return 0;
  
  fail:

  	hpfs_unlock(i->i_sb);

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

  	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 = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
  		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:

  	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,

  };