/*
   * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   */

  #include <linux/capability.h>

  #include <linux/fs.h>

  #include <linux/mount.h>

  #include "reiserfs.h"

  #include <linux/time.h>

  #include <linux/uaccess.h>

  #include <linux/pagemap.h>

  #include <linux/compat.h>

  /*

   * reiserfs_ioctl - handler for ioctl for inode
   * supported commands:
   *  1) REISERFS_IOC_UNPACK - try to unpack tail from direct item into indirect

   *                           and prevent packing file (argument arg has t
   *			      be non-zero)

   *  2) REISERFS_IOC_[GS]ETFLAGS, REISERFS_IOC_[GS]ETVERSION
   *  3) That's all for a while ...
   */

  long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

  {

  	struct inode *inode = file_inode(filp);

  	unsigned int flags;

  	int err = 0;

  	reiserfs_write_lock(inode->i_sb);

  	switch (cmd) {

  	case REISERFS_IOC_UNPACK:
  		if (S_ISREG(inode->i_mode)) {
  			if (arg)

  				err = reiserfs_unpack(inode, filp);

  		} else

  			err = -ENOTTY;
  		break;
  		/*
  		 * following two cases are taken from fs/ext2/ioctl.c by Remy
  		 * Card (card@masi.ibp.fr)
  		 */

  	case REISERFS_IOC_GETFLAGS:

  		if (!reiserfs_attrs(inode->i_sb)) {
  			err = -ENOTTY;
  			break;
  		}

  		flags = REISERFS_I(inode)->i_attrs;

  		err = put_user(flags, (int __user *)arg);
  		break;

  	case REISERFS_IOC_SETFLAGS:{

  			if (!reiserfs_attrs(inode->i_sb)) {
  				err = -ENOTTY;
  				break;
  			}

  			err = mnt_want_write_file(filp);

  			if (err)

  				break;

  			if (!inode_owner_or_capable(inode)) {

  				err = -EPERM;
  				goto setflags_out;
  			}
  			if (get_user(flags, (int __user *)arg)) {
  				err = -EFAULT;
  				goto setflags_out;
  			}
  			/*
  			 * Is it quota file? Do not allow user to mess with it
  			 */
  			if (IS_NOQUOTA(inode)) {
  				err = -EPERM;
  				goto setflags_out;
  			}

  			err = vfs_ioc_setflags_prepare(inode,
  						     REISERFS_I(inode)->i_attrs,
  						     flags);
  			if (err)

  				goto setflags_out;

  			if ((flags & REISERFS_NOTAIL_FL) &&
  			    S_ISREG(inode->i_mode)) {

  				int result;

  				result = reiserfs_unpack(inode, filp);

  				if (result) {
  					err = result;
  					goto setflags_out;
  				}

  			}
  			sd_attrs_to_i_attrs(flags, inode);
  			REISERFS_I(inode)->i_attrs = flags;

  			inode->i_ctime = current_time(inode);

  			mark_inode_dirty(inode);

  setflags_out:

  			mnt_drop_write_file(filp);

  			break;

  		}

  	case REISERFS_IOC_GETVERSION:

  		err = put_user(inode->i_generation, (int __user *)arg);
  		break;

  	case REISERFS_IOC_SETVERSION:

  		if (!inode_owner_or_capable(inode)) {

  			err = -EPERM;
  			break;

  		}

  		err = mnt_want_write_file(filp);

  		if (err)

  			break;

  		if (get_user(inode->i_generation, (int __user *)arg)) {
  			err = -EFAULT;
  			goto setversion_out;
  		}

  		inode->i_ctime = current_time(inode);

  		mark_inode_dirty(inode);

  setversion_out:

  		mnt_drop_write_file(filp);

  		break;

  	default:

  		err = -ENOTTY;

  	}

  
  	reiserfs_write_unlock(inode->i_sb);
  
  	return err;

  }

  #ifdef CONFIG_COMPAT
  long reiserfs_compat_ioctl(struct file *file, unsigned int cmd,
  				unsigned long arg)
  {

  	/*
  	 * These are just misnamed, they actually
  	 * get/put from/to user an int
  	 */

  	switch (cmd) {
  	case REISERFS_IOC32_UNPACK:
  		cmd = REISERFS_IOC_UNPACK;
  		break;
  	case REISERFS_IOC32_GETFLAGS:
  		cmd = REISERFS_IOC_GETFLAGS;
  		break;
  	case REISERFS_IOC32_SETFLAGS:
  		cmd = REISERFS_IOC_SETFLAGS;
  		break;
  	case REISERFS_IOC32_GETVERSION:
  		cmd = REISERFS_IOC_GETVERSION;
  		break;
  	case REISERFS_IOC32_SETVERSION:
  		cmd = REISERFS_IOC_SETVERSION;
  		break;
  	default:
  		return -ENOIOCTLCMD;
  	}

  	return reiserfs_ioctl(file, cmd, (unsigned long) compat_ptr(arg));

  }
  #endif

  int reiserfs_commit_write(struct file *f, struct page *page,
  			  unsigned from, unsigned to);

  /*

   * reiserfs_unpack
   * Function try to convert tail from direct item into indirect.
   * It set up nopack attribute in the REISERFS_I(inode)->nopack
   */

  int reiserfs_unpack(struct inode *inode, struct file *filp)

  {

  	int retval = 0;
  	int index;
  	struct page *page;
  	struct address_space *mapping;
  	unsigned long write_from;
  	unsigned long blocksize = inode->i_sb->s_blocksize;
  
  	if (inode->i_size == 0) {
  		REISERFS_I(inode)->i_flags |= i_nopack_mask;
  		return 0;
  	}
  	/* ioctl already done */
  	if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
  		return 0;
  	}

  	/* we need to make sure nobody is changing the file size beneath us */

  {
  	int depth = reiserfs_write_unlock_nested(inode->i_sb);
  	inode_lock(inode);
  	reiserfs_write_lock_nested(inode->i_sb, depth);
  }

  	reiserfs_write_lock(inode->i_sb);

  	write_from = inode->i_size & (blocksize - 1);
  	/* if we are on a block boundary, we are already unpacked.  */
  	if (write_from == 0) {
  		REISERFS_I(inode)->i_flags |= i_nopack_mask;
  		goto out;
  	}

  	/*
  	 * we unpack by finding the page with the tail, and calling
  	 * __reiserfs_write_begin on that page.  This will force a
  	 * reiserfs_get_block to unpack the tail for us.

  	 */

  	index = inode->i_size >> PAGE_SHIFT;

  	mapping = inode->i_mapping;
  	page = grab_cache_page(mapping, index);
  	retval = -ENOMEM;
  	if (!page) {
  		goto out;
  	}

  	retval = __reiserfs_write_begin(page, write_from, 0);

  	if (retval)
  		goto out_unlock;
  
  	/* conversion can change page contents, must flush */
  	flush_dcache_page(page);

  	retval = reiserfs_commit_write(NULL, page, write_from, write_from);

  	REISERFS_I(inode)->i_flags |= i_nopack_mask;

  out_unlock:

  	unlock_page(page);

  	put_page(page);

  out:

  	inode_unlock(inode);

  	reiserfs_write_unlock(inode->i_sb);

  	return retval;

  }