/*
   *   fs/cifs/inode.c
   *

   *   Copyright (C) International Business Machines  Corp., 2002,2010

   *   Author(s): Steve French (sfrench@us.ibm.com)
   *
   *   This library is free software; you can redistribute it and/or modify
   *   it under the terms of the GNU Lesser General Public License as published
   *   by the Free Software Foundation; either version 2.1 of the License, or
   *   (at your option) any later version.
   *
   *   This library is distributed in the hope that it will be useful,
   *   but WITHOUT ANY WARRANTY; without even the implied warranty of
   *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
   *   the GNU Lesser General Public License for more details.
   *
   *   You should have received a copy of the GNU Lesser General Public License
   *   along with this library; if not, write to the Free Software
   *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
   */
  #include <linux/fs.h>

  #include <linux/stat.h>

  #include <linux/slab.h>

  #include <linux/pagemap.h>
  #include <asm/div64.h>
  #include "cifsfs.h"
  #include "cifspdu.h"
  #include "cifsglob.h"
  #include "cifsproto.h"
  #include "cifs_debug.h"
  #include "cifs_fs_sb.h"

  #include "fscache.h"

  static void cifs_set_ops(struct inode *inode)

  {
  	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  
  	switch (inode->i_mode & S_IFMT) {
  	case S_IFREG:
  		inode->i_op = &cifs_file_inode_ops;
  		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  				inode->i_fop = &cifs_file_direct_nobrl_ops;
  			else
  				inode->i_fop = &cifs_file_direct_ops;

  		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  				inode->i_fop = &cifs_file_strict_nobrl_ops;
  			else
  				inode->i_fop = &cifs_file_strict_ops;

  		} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  			inode->i_fop = &cifs_file_nobrl_ops;
  		else { /* not direct, send byte range locks */
  			inode->i_fop = &cifs_file_ops;
  		}

  		/* check if server can support readpages */

  		if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <

  				PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
  			inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  		else
  			inode->i_data.a_ops = &cifs_addr_ops;
  		break;
  	case S_IFDIR:

  #ifdef CONFIG_CIFS_DFS_UPCALL

  		if (IS_AUTOMOUNT(inode)) {

  			inode->i_op = &cifs_dfs_referral_inode_operations;
  		} else {

  #else /* NO DFS support, treat as a directory */
  		{
  #endif

  			inode->i_op = &cifs_dir_inode_ops;
  			inode->i_fop = &cifs_dir_ops;
  		}

  		break;
  	case S_IFLNK:
  		inode->i_op = &cifs_symlink_inode_ops;
  		break;
  	default:
  		init_special_inode(inode, inode->i_mode, inode->i_rdev);
  		break;
  	}
  }

  /* check inode attributes against fattr. If they don't match, tag the
   * inode for cache invalidation
   */
  static void
  cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
  {
  	struct cifsInodeInfo *cifs_i = CIFS_I(inode);

  	cFYI(1, "%s: revalidating inode %llu", __func__, cifs_i->uniqueid);

  
  	if (inode->i_state & I_NEW) {

  		cFYI(1, "%s: inode %llu is new", __func__, cifs_i->uniqueid);

  		return;
  	}
  
  	/* don't bother with revalidation if we have an oplock */
  	if (cifs_i->clientCanCacheRead) {

  		cFYI(1, "%s: inode %llu is oplocked", __func__,
  			 cifs_i->uniqueid);

  		return;
  	}
  
  	 /* revalidate if mtime or size have changed */
  	if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
  	    cifs_i->server_eof == fattr->cf_eof) {

  		cFYI(1, "%s: inode %llu is unchanged", __func__,
  			 cifs_i->uniqueid);

  		return;
  	}

  	cFYI(1, "%s: invalidating inode %llu mapping", __func__,
  		 cifs_i->uniqueid);

  	cifs_i->invalid_mapping = true;
  }

  /* populate an inode with info from a cifs_fattr struct */
  void
  cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)

  {

  	struct cifsInodeInfo *cifs_i = CIFS_I(inode);

  	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  	unsigned long oldtime = cifs_i->time;

  	cifs_revalidate_cache(inode, fattr);

  	inode->i_atime = fattr->cf_atime;
  	inode->i_mtime = fattr->cf_mtime;
  	inode->i_ctime = fattr->cf_ctime;

  	inode->i_rdev = fattr->cf_rdev;

  	set_nlink(inode, fattr->cf_nlink);

  	inode->i_uid = fattr->cf_uid;
  	inode->i_gid = fattr->cf_gid;

  	/* if dynperm is set, don't clobber existing mode */
  	if (inode->i_state & I_NEW ||
  	    !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
  		inode->i_mode = fattr->cf_mode;

  	cifs_i->cifsAttrs = fattr->cf_cifsattrs;

  	if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
  		cifs_i->time = 0;
  	else
  		cifs_i->time = jiffies;

  	cFYI(1, "inode 0x%p old_time=%ld new_time=%ld", inode,
  		 oldtime, cifs_i->time);

  
  	cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;

  	cifs_i->server_eof = fattr->cf_eof;

  	/*
  	 * Can't safely change the file size here if the client is writing to
  	 * it due to potential races.
  	 */
  	spin_lock(&inode->i_lock);
  	if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
  		i_size_write(inode, fattr->cf_eof);
  
  		/*
  		 * i_blocks is not related to (i_size / i_blksize),
  		 * but instead 512 byte (2**9) size is required for
  		 * calculating num blocks.
  		 */
  		inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
  	}
  	spin_unlock(&inode->i_lock);

  	if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
  		inode->i_flags |= S_AUTOMOUNT;
  	cifs_set_ops(inode);

  }

  void
  cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
  {
  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
  
  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
  		return;
  
  	fattr->cf_uniqueid = iunique(sb, ROOT_I);
  }

  /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
  void
  cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
  			 struct cifs_sb_info *cifs_sb)
  {
  	memset(fattr, 0, sizeof(*fattr));
  	fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
  	fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
  	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
  
  	fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
  	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
  	fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
  	fattr->cf_mode = le64_to_cpu(info->Permissions);

  
  	/*
  	 * Since we set the inode type below we need to mask off
  	 * to avoid strange results if bits set above.
  	 */

  	fattr->cf_mode &= ~S_IFMT;

  	switch (le32_to_cpu(info->Type)) {
  	case UNIX_FILE:

  		fattr->cf_mode |= S_IFREG;
  		fattr->cf_dtype = DT_REG;

  		break;
  	case UNIX_SYMLINK:

  		fattr->cf_mode |= S_IFLNK;
  		fattr->cf_dtype = DT_LNK;

  		break;
  	case UNIX_DIR:

  		fattr->cf_mode |= S_IFDIR;
  		fattr->cf_dtype = DT_DIR;

  		break;
  	case UNIX_CHARDEV:

  		fattr->cf_mode |= S_IFCHR;
  		fattr->cf_dtype = DT_CHR;
  		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
  				       le64_to_cpu(info->DevMinor) & MINORMASK);

  		break;
  	case UNIX_BLOCKDEV:

  		fattr->cf_mode |= S_IFBLK;
  		fattr->cf_dtype = DT_BLK;
  		fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
  				       le64_to_cpu(info->DevMinor) & MINORMASK);

  		break;
  	case UNIX_FIFO:

  		fattr->cf_mode |= S_IFIFO;
  		fattr->cf_dtype = DT_FIFO;

  		break;
  	case UNIX_SOCKET:

  		fattr->cf_mode |= S_IFSOCK;
  		fattr->cf_dtype = DT_SOCK;

  		break;
  	default:
  		/* safest to call it a file if we do not know */

  		fattr->cf_mode |= S_IFREG;
  		fattr->cf_dtype = DT_REG;

  		cFYI(1, "unknown type %d", le32_to_cpu(info->Type));

  		break;
  	}

  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
  		fattr->cf_uid = cifs_sb->mnt_uid;

  	else

  		fattr->cf_uid = le64_to_cpu(info->Uid);

  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
  		fattr->cf_gid = cifs_sb->mnt_gid;

  	else

  		fattr->cf_gid = le64_to_cpu(info->Gid);

  	fattr->cf_nlink = le64_to_cpu(info->Nlinks);

  }

  /*

   * Fill a cifs_fattr struct with fake inode info.
   *
   * Needed to setup cifs_fattr data for the directory which is the
   * junction to the new submount (ie to setup the fake directory
   * which represents a DFS referral).

   */

  static void

  cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)

  {

  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

  	cFYI(1, "creating fake fattr for DFS referral");

  
  	memset(fattr, 0, sizeof(*fattr));
  	fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
  	fattr->cf_uid = cifs_sb->mnt_uid;
  	fattr->cf_gid = cifs_sb->mnt_gid;
  	fattr->cf_atime = CURRENT_TIME;
  	fattr->cf_ctime = CURRENT_TIME;
  	fattr->cf_mtime = CURRENT_TIME;
  	fattr->cf_nlink = 2;
  	fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;

  }

  int cifs_get_file_info_unix(struct file *filp)
  {
  	int rc;
  	int xid;
  	FILE_UNIX_BASIC_INFO find_data;
  	struct cifs_fattr fattr;
  	struct inode *inode = filp->f_path.dentry->d_inode;
  	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);

  	struct cifsFileInfo *cfile = filp->private_data;

  	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);

  
  	xid = GetXid();
  	rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->netfid, &find_data);
  	if (!rc) {
  		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
  	} else if (rc == -EREMOTE) {
  		cifs_create_dfs_fattr(&fattr, inode->i_sb);
  		rc = 0;
  	}
  
  	cifs_fattr_to_inode(inode, &fattr);
  	FreeXid(xid);
  	return rc;
  }

  int cifs_get_inode_info_unix(struct inode **pinode,

  			     const unsigned char *full_path,
  			     struct super_block *sb, int xid)

  {

  	int rc;

  	FILE_UNIX_BASIC_INFO find_data;

  	struct cifs_fattr fattr;

  	struct cifs_tcon *tcon;

  	struct tcon_link *tlink;

  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

  	cFYI(1, "Getting info on %s", full_path);

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	tcon = tlink_tcon(tlink);

  	/* could have done a find first instead but this returns more info */

  	rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,

  				  cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
  					CIFS_MOUNT_MAP_SPECIAL_CHR);

  	cifs_put_tlink(tlink);

  	if (!rc) {
  		cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
  	} else if (rc == -EREMOTE) {
  		cifs_create_dfs_fattr(&fattr, sb);
  		rc = 0;
  	} else {
  		return rc;
  	}

  	/* check for Minshall+French symlinks */
  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
  		int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
  		if (tmprc)
  			cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
  	}

  	if (*pinode == NULL) {

  		/* get new inode */

  		cifs_fill_uniqueid(sb, &fattr);

  		*pinode = cifs_iget(sb, &fattr);
  		if (!*pinode)

  			rc = -ENOMEM;

  	} else {
  		/* we already have inode, update it */
  		cifs_fattr_to_inode(*pinode, &fattr);

  	}

  	return rc;
  }

  static int
  cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
  	      struct cifs_sb_info *cifs_sb, int xid)

  {
  	int rc;

  	int oplock = 0;

  	__u16 netfid;

  	struct tcon_link *tlink;

  	struct cifs_tcon *tcon;

  	struct cifs_io_parms io_parms;

  	char buf[24];

  	unsigned int bytes_read;

  	char *pbuf;

  
  	pbuf = buf;

  	fattr->cf_mode &= ~S_IFMT;
  
  	if (fattr->cf_eof == 0) {
  		fattr->cf_mode |= S_IFIFO;
  		fattr->cf_dtype = DT_FIFO;

  		return 0;

  	} else if (fattr->cf_eof < 8) {
  		fattr->cf_mode |= S_IFREG;
  		fattr->cf_dtype = DT_REG;

  		return -EINVAL;	 /* EOPNOTSUPP? */
  	}

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	tcon = tlink_tcon(tlink);
  
  	rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,

  			 CREATE_NOT_DIR, &netfid, &oplock, NULL,
  			 cifs_sb->local_nls,
  			 cifs_sb->mnt_cifs_flags &
  				CIFS_MOUNT_MAP_SPECIAL_CHR);

  	if (rc == 0) {

  		int buf_type = CIFS_NO_BUFFER;

  			/* Read header */

  		io_parms.netfid = netfid;
  		io_parms.pid = current->tgid;
  		io_parms.tcon = tcon;
  		io_parms.offset = 0;
  		io_parms.length = 24;
  		rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
  				 &buf_type);

  		if ((rc == 0) && (bytes_read >= 8)) {
  			if (memcmp("IntxBLK", pbuf, 8) == 0) {

  				cFYI(1, "Block device");

  				fattr->cf_mode |= S_IFBLK;
  				fattr->cf_dtype = DT_BLK;

  				if (bytes_read == 24) {

  					/* we have enough to decode dev num */
  					__u64 mjr; /* major */
  					__u64 mnr; /* minor */
  					mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
  					mnr = le64_to_cpu(*(__le64 *)(pbuf+16));

  					fattr->cf_rdev = MKDEV(mjr, mnr);

  				}

  			} else if (memcmp("IntxCHR", pbuf, 8) == 0) {

  				cFYI(1, "Char device");

  				fattr->cf_mode |= S_IFCHR;
  				fattr->cf_dtype = DT_CHR;

  				if (bytes_read == 24) {

  					/* we have enough to decode dev num */
  					__u64 mjr; /* major */
  					__u64 mnr; /* minor */
  					mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
  					mnr = le64_to_cpu(*(__le64 *)(pbuf+16));

  					fattr->cf_rdev = MKDEV(mjr, mnr);

  				}

  			} else if (memcmp("IntxLNK", pbuf, 7) == 0) {

  				cFYI(1, "Symlink");

  				fattr->cf_mode |= S_IFLNK;
  				fattr->cf_dtype = DT_LNK;

  			} else {

  				fattr->cf_mode |= S_IFREG; /* file? */
  				fattr->cf_dtype = DT_REG;

  				rc = -EOPNOTSUPP;

  			}

  		} else {

  			fattr->cf_mode |= S_IFREG; /* then it is a file */
  			fattr->cf_dtype = DT_REG;

  			rc = -EOPNOTSUPP; /* or some unknown SFU type */
  		}

  		CIFSSMBClose(xid, tcon, netfid);

  	}

  	cifs_put_tlink(tlink);

  	return rc;

  }

  #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */

  /*
   * Fetch mode bits as provided by SFU.
   *
   * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
   */
  static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
  			 struct cifs_sb_info *cifs_sb, int xid)

  {

  #ifdef CONFIG_CIFS_XATTR

  	ssize_t rc;
  	char ea_value[4];
  	__u32 mode;

  	struct tcon_link *tlink;

  	struct cifs_tcon *tcon;

  
  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	tcon = tlink_tcon(tlink);

  	rc = CIFSSMBQAllEAs(xid, tcon, path, "SETFILEBITS",

  			    ea_value, 4 /* size of buf */, cifs_sb->local_nls,
  			    cifs_sb->mnt_cifs_flags &
  				CIFS_MOUNT_MAP_SPECIAL_CHR);

  	cifs_put_tlink(tlink);

  	if (rc < 0)

  		return (int)rc;
  	else if (rc > 3) {
  		mode = le32_to_cpu(*((__le32 *)ea_value));

  		fattr->cf_mode &= ~SFBITS_MASK;

  		cFYI(1, "special bits 0%o org mode 0%o", mode,
  			 fattr->cf_mode);

  		fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;

  		cFYI(1, "special mode bits 0%o", mode);

  	}

  
  	return 0;

  #else
  	return -EOPNOTSUPP;
  #endif

  }

  /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */

  static void

  cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
  		       struct cifs_sb_info *cifs_sb, bool adjust_tz)

  {

  	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);

  	memset(fattr, 0, sizeof(*fattr));
  	fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
  	if (info->DeletePending)
  		fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
  
  	if (info->LastAccessTime)
  		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
  	else
  		fattr->cf_atime = CURRENT_TIME;
  
  	fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
  	fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
  
  	if (adjust_tz) {

  		fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
  		fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;

  	}
  
  	fattr->cf_eof = le64_to_cpu(info->EndOfFile);
  	fattr->cf_bytes = le64_to_cpu(info->AllocationSize);

  	fattr->cf_createtime = le64_to_cpu(info->CreationTime);

  
  	if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
  		fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
  		fattr->cf_dtype = DT_DIR;
  	} else {
  		fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
  		fattr->cf_dtype = DT_REG;

  		/* clear write bits if ATTR_READONLY is set */
  		if (fattr->cf_cifsattrs & ATTR_READONLY)
  			fattr->cf_mode &= ~(S_IWUGO);
  	}

  
  	fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
  
  	fattr->cf_uid = cifs_sb->mnt_uid;
  	fattr->cf_gid = cifs_sb->mnt_gid;

  }

  int cifs_get_file_info(struct file *filp)
  {
  	int rc;
  	int xid;
  	FILE_ALL_INFO find_data;
  	struct cifs_fattr fattr;
  	struct inode *inode = filp->f_path.dentry->d_inode;
  	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);

  	struct cifsFileInfo *cfile = filp->private_data;

  	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);

  
  	xid = GetXid();
  	rc = CIFSSMBQFileInfo(xid, tcon, cfile->netfid, &find_data);

  	switch (rc) {
  	case 0:
  		cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
  		break;
  	case -EREMOTE:
  		cifs_create_dfs_fattr(&fattr, inode->i_sb);
  		rc = 0;
  		break;
  	case -EOPNOTSUPP:
  	case -EINVAL:

  		/*
  		 * FIXME: legacy server -- fall back to path-based call?

  		 * for now, just skip revalidating and mark inode for
  		 * immediate reval.
  		 */

  		rc = 0;
  		CIFS_I(inode)->time = 0;

  	default:

  		goto cgfi_exit;

  	}

  
  	/*
  	 * don't bother with SFU junk here -- just mark inode as needing
  	 * revalidation.
  	 */

  	fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
  	fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
  	cifs_fattr_to_inode(inode, &fattr);
  cgfi_exit:
  	FreeXid(xid);
  	return rc;
  }

  int cifs_get_inode_info(struct inode **pinode,

  	const unsigned char *full_path, FILE_ALL_INFO *pfindData,

  	struct super_block *sb, int xid, const __u16 *pfid)

  {

  	int rc = 0, tmprc;

  	struct cifs_tcon *pTcon;

  	struct tcon_link *tlink;

  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

  	char *buf = NULL;

  	bool adjustTZ = false;

  	struct cifs_fattr fattr;

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	pTcon = tlink_tcon(tlink);

  	cFYI(1, "Getting info on %s", full_path);

  	if ((pfindData == NULL) && (*pinode != NULL)) {
  		if (CIFS_I(*pinode)->clientCanCacheRead) {

  			cFYI(1, "No need to revalidate cached inode sizes");

  			goto cgii_exit;

  		}
  	}
  
  	/* if file info not passed in then get it from server */

  	if (pfindData == NULL) {

  		buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);

  		if (buf == NULL) {
  			rc = -ENOMEM;
  			goto cgii_exit;
  		}

  		pfindData = (FILE_ALL_INFO *)buf;

  		/* could do find first instead but this returns more info */

  		rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,

  			      0 /* not legacy */,

  			      cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &

  				CIFS_MOUNT_MAP_SPECIAL_CHR);

  		/* BB optimize code so we do not make the above call
  		when server claims no NT SMB support and the above call
  		failed at least once - set flag in tcon or mount */

  		if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {

  			rc = SMBQueryInformation(xid, pTcon, full_path,

  					pfindData, cifs_sb->local_nls,

  					cifs_sb->mnt_cifs_flags &
  					  CIFS_MOUNT_MAP_SPECIAL_CHR);

  			adjustTZ = true;

  		}

  	}

  
  	if (!rc) {
  		cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *) pfindData,
  				       cifs_sb, adjustTZ);
  	} else if (rc == -EREMOTE) {
  		cifs_create_dfs_fattr(&fattr, sb);

  		rc = 0;

  	} else {

  		goto cgii_exit;

  	}

  	/*
  	 * If an inode wasn't passed in, then get the inode number
  	 *
  	 * Is an i_ino of zero legal? Can we use that to check if the server
  	 * supports returning inode numbers?  Are there other sanity checks we
  	 * can use to ensure that the server is really filling in that field?
  	 *
  	 * We can not use the IndexNumber field by default from Windows or
  	 * Samba (in ALL_INFO buf) but we can request it explicitly. The SNIA
  	 * CIFS spec claims that this value is unique within the scope of a
  	 * share, and the windows docs hint that it's actually unique
  	 * per-machine.
  	 *
  	 * There may be higher info levels that work but are there Windows
  	 * server or network appliances for which IndexNumber field is not
  	 * guaranteed unique?
  	 */

  	if (*pinode == NULL) {

  		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
  			int rc1 = 0;

  
  			rc1 = CIFSGetSrvInodeNumber(xid, pTcon,

  					full_path, &fattr.cf_uniqueid,

  					cifs_sb->local_nls,
  					cifs_sb->mnt_cifs_flags &
  						CIFS_MOUNT_MAP_SPECIAL_CHR);

  			if (rc1 || !fattr.cf_uniqueid) {

  				cFYI(1, "GetSrvInodeNum rc %d", rc1);

  				fattr.cf_uniqueid = iunique(sb, ROOT_I);

  				cifs_autodisable_serverino(cifs_sb);

  			}

  		} else {

  			fattr.cf_uniqueid = iunique(sb, ROOT_I);

  		}

  	} else {

  		fattr.cf_uniqueid = CIFS_I(*pinode)->uniqueid;

  	}

  	/* query for SFU type info if supported and needed */
  	if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
  	    cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
  		tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
  		if (tmprc)

  			cFYI(1, "cifs_sfu_type failed: %d", tmprc);

  	}

  #ifdef CONFIG_CIFS_ACL

  	/* fill in 0777 bits from ACL */
  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {

  		rc = cifs_acl_to_fattr(cifs_sb, &fattr, *pinode, full_path,
  						pfid);
  		if (rc) {
  			cFYI(1, "%s: Getting ACL failed with error: %d",
  				__func__, rc);
  			goto cgii_exit;
  		}

  	}

  #endif /* CONFIG_CIFS_ACL */

  	/* fill in remaining high mode bits e.g. SUID, VTX */
  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
  		cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);

  	/* check for Minshall+French symlinks */
  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
  		tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
  		if (tmprc)
  			cFYI(1, "CIFSCheckMFSymlink: %d", tmprc);
  	}

  	if (!*pinode) {
  		*pinode = cifs_iget(sb, &fattr);
  		if (!*pinode)
  			rc = -ENOMEM;
  	} else {
  		cifs_fattr_to_inode(*pinode, &fattr);
  	}

  cgii_exit:

  	kfree(buf);

  	cifs_put_tlink(tlink);

  	return rc;
  }

  static const struct inode_operations cifs_ipc_inode_ops = {
  	.lookup = cifs_lookup,
  };

  char *cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,

  			      struct cifs_tcon *tcon)

  {

  	int pplen = vol->prepath ? strlen(vol->prepath) : 0;

  	int dfsplen;
  	char *full_path = NULL;
  
  	/* if no prefix path, simply set path to the root of share to "" */
  	if (pplen == 0) {
  		full_path = kmalloc(1, GFP_KERNEL);
  		if (full_path)
  			full_path[0] = 0;
  		return full_path;
  	}

  	if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
  		dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);

  	else
  		dfsplen = 0;
  
  	full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
  	if (full_path == NULL)
  		return full_path;

  	if (dfsplen)

  		strncpy(full_path, tcon->treeName, dfsplen);

  	strncpy(full_path + dfsplen, vol->prepath, pplen);

  	convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));

  	full_path[dfsplen + pplen] = 0; /* add trailing null */
  	return full_path;
  }

  static int
  cifs_find_inode(struct inode *inode, void *opaque)
  {
  	struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;

  	/* don't match inode with different uniqueid */

  	if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
  		return 0;

  	/* use createtime like an i_generation field */
  	if (CIFS_I(inode)->createtime != fattr->cf_createtime)
  		return 0;

  	/* don't match inode of different type */
  	if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
  		return 0;

  	/* if it's not a directory or has no dentries, then flag it */
  	if (S_ISDIR(inode->i_mode) && !list_empty(&inode->i_dentry))

  		fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;

  	return 1;
  }
  
  static int
  cifs_init_inode(struct inode *inode, void *opaque)
  {
  	struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
  
  	CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;

  	CIFS_I(inode)->createtime = fattr->cf_createtime;

  	return 0;
  }

  /*
   * walk dentry list for an inode and report whether it has aliases that
   * are hashed. We use this to determine if a directory inode can actually
   * be used.
   */
  static bool
  inode_has_hashed_dentries(struct inode *inode)
  {
  	struct dentry *dentry;

  	spin_lock(&inode->i_lock);

  	list_for_each_entry(dentry, &inode->i_dentry, d_alias) {
  		if (!d_unhashed(dentry) || IS_ROOT(dentry)) {

  			spin_unlock(&inode->i_lock);

  			return true;
  		}
  	}

  	spin_unlock(&inode->i_lock);

  	return false;
  }

  /* Given fattrs, get a corresponding inode */
  struct inode *
  cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
  {
  	unsigned long hash;
  	struct inode *inode;

  retry_iget5_locked:

  	cFYI(1, "looking for uniqueid=%llu", fattr->cf_uniqueid);

  
  	/* hash down to 32-bits on 32-bit arch */
  	hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
  
  	inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);

  	if (inode) {

  		/* was there a potentially problematic inode collision? */

  		if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {

  			fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;

  
  			if (inode_has_hashed_dentries(inode)) {
  				cifs_autodisable_serverino(CIFS_SB(sb));
  				iput(inode);
  				fattr->cf_uniqueid = iunique(sb, ROOT_I);
  				goto retry_iget5_locked;
  			}

  		}

  		cifs_fattr_to_inode(inode, fattr);
  		if (sb->s_flags & MS_NOATIME)
  			inode->i_flags |= S_NOATIME | S_NOCMTIME;
  		if (inode->i_state & I_NEW) {
  			inode->i_ino = hash;

  			if (S_ISREG(inode->i_mode))
  				inode->i_data.backing_dev_info = sb->s_bdi;

  #ifdef CONFIG_CIFS_FSCACHE

  			/* initialize per-inode cache cookie pointer */
  			CIFS_I(inode)->fscache = NULL;

  #endif

  			unlock_new_inode(inode);
  		}
  	}
  
  	return inode;
  }

  /* gets root inode */

  struct inode *cifs_root_iget(struct super_block *sb)

  {

  	int xid;

  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

  	struct inode *inode = NULL;

  	long rc;

  	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);

  	xid = GetXid();

  	if (tcon->unix_ext)

  		rc = cifs_get_inode_info_unix(&inode, "", sb, xid);

  	else

  		rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);

  	if (!inode) {
  		inode = ERR_PTR(rc);
  		goto out;
  	}

  #ifdef CONFIG_CIFS_FSCACHE

  	/* populate tcon->resource_id */

  	tcon->resource_id = CIFS_I(inode)->uniqueid;

  #endif

  	if (rc && tcon->ipc) {

  		cFYI(1, "ipc connection - fake read inode");

  		inode->i_mode |= S_IFDIR;

  		set_nlink(inode, 2);

  		inode->i_op = &cifs_ipc_inode_ops;
  		inode->i_fop = &simple_dir_operations;
  		inode->i_uid = cifs_sb->mnt_uid;
  		inode->i_gid = cifs_sb->mnt_gid;

  	} else if (rc) {

  		iget_failed(inode);

  		inode = ERR_PTR(rc);

  	}

  out:

  	/* can not call macro FreeXid here since in a void func
  	 * TODO: This is no longer true
  	 */

  	_FreeXid(xid);

  	return inode;

  }

  static int
  cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
  		    char *full_path, __u32 dosattr)
  {
  	int rc;
  	int oplock = 0;
  	__u16 netfid;
  	__u32 netpid;
  	bool set_time = false;
  	struct cifsFileInfo *open_file;
  	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
  	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);

  	struct tcon_link *tlink = NULL;

  	struct cifs_tcon *pTcon;

  	FILE_BASIC_INFO	info_buf;

  	if (attrs == NULL)
  		return -EINVAL;

  	if (attrs->ia_valid & ATTR_ATIME) {
  		set_time = true;
  		info_buf.LastAccessTime =
  			cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
  	} else
  		info_buf.LastAccessTime = 0;
  
  	if (attrs->ia_valid & ATTR_MTIME) {
  		set_time = true;
  		info_buf.LastWriteTime =
  		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
  	} else
  		info_buf.LastWriteTime = 0;
  
  	/*
  	 * Samba throws this field away, but windows may actually use it.
  	 * Do not set ctime unless other time stamps are changed explicitly
  	 * (i.e. by utimes()) since we would then have a mix of client and
  	 * server times.
  	 */
  	if (set_time && (attrs->ia_valid & ATTR_CTIME)) {

  		cFYI(1, "CIFS - CTIME changed");

  		info_buf.ChangeTime =
  		    cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
  	} else
  		info_buf.ChangeTime = 0;
  
  	info_buf.CreationTime = 0;	/* don't change */
  	info_buf.Attributes = cpu_to_le32(dosattr);
  
  	/*
  	 * If the file is already open for write, just use that fileid
  	 */

  	open_file = find_writable_file(cifsInode, true);

  	if (open_file) {
  		netfid = open_file->netfid;
  		netpid = open_file->pid;

  		pTcon = tlink_tcon(open_file->tlink);

  		goto set_via_filehandle;
  	}

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink)) {
  		rc = PTR_ERR(tlink);
  		tlink = NULL;
  		goto out;
  	}
  	pTcon = tlink_tcon(tlink);

  	/*
  	 * NT4 apparently returns success on this call, but it doesn't
  	 * really work.
  	 */
  	if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
  		rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
  				     &info_buf, cifs_sb->local_nls,
  				     cifs_sb->mnt_cifs_flags &
  					CIFS_MOUNT_MAP_SPECIAL_CHR);

  		if (rc == 0) {
  			cifsInode->cifsAttrs = dosattr;
  			goto out;
  		} else if (rc != -EOPNOTSUPP && rc != -EINVAL)

  			goto out;
  	}

  	cFYI(1, "calling SetFileInfo since SetPathInfo for "
  		 "times not supported by this server");

  	rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
  			 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
  			 CREATE_NOT_DIR, &netfid, &oplock,
  			 NULL, cifs_sb->local_nls,
  			 cifs_sb->mnt_cifs_flags &
  				CIFS_MOUNT_MAP_SPECIAL_CHR);
  
  	if (rc != 0) {
  		if (rc == -EIO)
  			rc = -EINVAL;
  		goto out;
  	}
  
  	netpid = current->tgid;
  
  set_via_filehandle:
  	rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);

  	if (!rc)
  		cifsInode->cifsAttrs = dosattr;

  	if (open_file == NULL)
  		CIFSSMBClose(xid, pTcon, netfid);
  	else

  		cifsFileInfo_put(open_file);

  out:

  	if (tlink != NULL)
  		cifs_put_tlink(tlink);

  	return rc;
  }

  /*
   * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
   * and rename it to a random name that hopefully won't conflict with
   * anything else.
   */
  static int

  cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)

  {
  	int oplock = 0;
  	int rc;
  	__u16 netfid;

  	struct inode *inode = dentry->d_inode;

  	struct cifsInodeInfo *cifsInode = CIFS_I(inode);
  	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);

  	struct tcon_link *tlink;

  	struct cifs_tcon *tcon;

  	__u32 dosattr, origattr;
  	FILE_BASIC_INFO *info_buf = NULL;

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	tcon = tlink_tcon(tlink);

  	rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,

  			 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,

  			 &netfid, &oplock, NULL, cifs_sb->local_nls,
  			 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
  	if (rc != 0)
  		goto out;

  	origattr = cifsInode->cifsAttrs;
  	if (origattr == 0)
  		origattr |= ATTR_NORMAL;
  
  	dosattr = origattr & ~ATTR_READONLY;

  	if (dosattr == 0)
  		dosattr |= ATTR_NORMAL;
  	dosattr |= ATTR_HIDDEN;

  	/* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
  	if (dosattr != origattr) {
  		info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
  		if (info_buf == NULL) {
  			rc = -ENOMEM;
  			goto out_close;
  		}
  		info_buf->Attributes = cpu_to_le32(dosattr);
  		rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
  					current->tgid);
  		/* although we would like to mark the file hidden
   		   if that fails we will still try to rename it */

  		if (rc != 0)

  			cifsInode->cifsAttrs = dosattr;
  		else
  			dosattr = origattr; /* since not able to change them */

  	}

  	/* rename the file */
  	rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,

  				   cifs_sb->mnt_cifs_flags &
  					    CIFS_MOUNT_MAP_SPECIAL_CHR);

  	if (rc != 0) {
  		rc = -ETXTBSY;
  		goto undo_setattr;
  	}

  	/* try to set DELETE_ON_CLOSE */
  	if (!cifsInode->delete_pending) {
  		rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
  					       current->tgid);
  		/*
  		 * some samba versions return -ENOENT when we try to set the
  		 * file disposition here. Likely a samba bug, but work around
  		 * it for now. This means that some cifsXXX files may hang
  		 * around after they shouldn't.
  		 *
  		 * BB: remove this hack after more servers have the fix
  		 */
  		if (rc == -ENOENT)
  			rc = 0;
  		else if (rc != 0) {
  			rc = -ETXTBSY;
  			goto undo_rename;
  		}
  		cifsInode->delete_pending = true;
  	}

  out_close:
  	CIFSSMBClose(xid, tcon, netfid);
  out:

  	kfree(info_buf);

  	cifs_put_tlink(tlink);

  	return rc;

  
  	/*
  	 * reset everything back to the original state. Don't bother
  	 * dealing with errors here since we can't do anything about
  	 * them anyway.
  	 */
  undo_rename:
  	CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
  				cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
  					    CIFS_MOUNT_MAP_SPECIAL_CHR);
  undo_setattr:
  	if (dosattr != origattr) {
  		info_buf->Attributes = cpu_to_le32(origattr);
  		if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
  					current->tgid))
  			cifsInode->cifsAttrs = origattr;
  	}
  
  	goto out_close;

  }

  
  /*
   * If dentry->d_inode is null (usually meaning the cached dentry
   * is a negative dentry) then we would attempt a standard SMB delete, but

   * if that fails we can not attempt the fall back mechanisms on EACCESS
   * but will return the EACCESS to the caller. Note that the VFS does not call

   * unlink on negative dentries currently.
   */

  int cifs_unlink(struct inode *dir, struct dentry *dentry)

  {
  	int rc = 0;
  	int xid;

  	char *full_path = NULL;

  	struct inode *inode = dentry->d_inode;

  	struct cifsInodeInfo *cifs_inode;

  	struct super_block *sb = dir->i_sb;
  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

  	struct tcon_link *tlink;

  	struct cifs_tcon *tcon;

  	struct iattr *attrs = NULL;
  	__u32 dosattr = 0, origattr = 0;

  	cFYI(1, "cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry);

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	tcon = tlink_tcon(tlink);

  	xid = GetXid();

  	/* Unlink can be called from rename so we can not take the
  	 * sb->s_vfs_rename_mutex here */
  	full_path = build_path_from_dentry(dentry);

  	if (full_path == NULL) {

  		rc = -ENOMEM;

  		goto unlink_out;

  	}

  	if ((tcon->ses->capabilities & CAP_UNIX) &&

  		(CIFS_UNIX_POSIX_PATH_OPS_CAP &

  			le64_to_cpu(tcon->fsUnixInfo.Capability))) {
  		rc = CIFSPOSIXDelFile(xid, tcon, full_path,

  			SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,

  			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);

  		cFYI(1, "posix del rc %d", rc);

  		if ((rc == 0) || (rc == -ENOENT))
  			goto psx_del_no_retry;
  	}

  retry_std_delete:

  	rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,

  			cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);

  psx_del_no_retry:

  	if (!rc) {

  		if (inode)
  			drop_nlink(inode);

  	} else if (rc == -ENOENT) {

  		d_drop(dentry);

  	} else if (rc == -ETXTBSY) {

  		rc = cifs_rename_pending_delete(full_path, dentry, xid);

  		if (rc == 0)
  			drop_nlink(inode);

  	} else if ((rc == -EACCES) && (dosattr == 0) && inode) {

  		attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
  		if (attrs == NULL) {
  			rc = -ENOMEM;
  			goto out_reval;

  		}

  
  		/* try to reset dos attributes */

  		cifs_inode = CIFS_I(inode);
  		origattr = cifs_inode->cifsAttrs;

  		if (origattr == 0)
  			origattr |= ATTR_NORMAL;
  		dosattr = origattr & ~ATTR_READONLY;

  		if (dosattr == 0)
  			dosattr |= ATTR_NORMAL;
  		dosattr |= ATTR_HIDDEN;
  
  		rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);

  		if (rc != 0)
  			goto out_reval;

  
  		goto retry_std_delete;

  	}

  
  	/* undo the setattr if we errored out and it's needed */
  	if (rc != 0 && dosattr != 0)
  		cifs_set_file_info(inode, attrs, xid, full_path, origattr);

  out_reval:

  	if (inode) {

  		cifs_inode = CIFS_I(inode);
  		cifs_inode->time = 0;	/* will force revalidate to get info

  					   when needed */
  		inode->i_ctime = current_fs_time(sb);

  	}

  	dir->i_ctime = dir->i_mtime = current_fs_time(sb);

  	cifs_inode = CIFS_I(dir);

  	CIFS_I(dir)->time = 0;	/* force revalidate of dir as well */

  unlink_out:

  	kfree(full_path);

  	kfree(attrs);

  	FreeXid(xid);

  	cifs_put_tlink(tlink);

  	return rc;
  }

  int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)

  {

  	int rc = 0, tmprc;

  	int xid;
  	struct cifs_sb_info *cifs_sb;

  	struct tcon_link *tlink;

  	struct cifs_tcon *pTcon;

  	char *full_path = NULL;
  	struct inode *newinode = NULL;

  	struct cifs_fattr fattr;

  	cFYI(1, "In cifs_mkdir, mode = 0x%hx inode = 0x%p", mode, inode);

  	cifs_sb = CIFS_SB(inode->i_sb);

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	pTcon = tlink_tcon(tlink);
  
  	xid = GetXid();

  	full_path = build_path_from_dentry(direntry);

  	if (full_path == NULL) {

  		rc = -ENOMEM;

  		goto mkdir_out;

  	}

  	if ((pTcon->ses->capabilities & CAP_UNIX) &&
  		(CIFS_UNIX_POSIX_PATH_OPS_CAP &

  			le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
  		u32 oplock = 0;

  		FILE_UNIX_BASIC_INFO *pInfo =

  			kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);

  		if (pInfo == NULL) {

  			rc = -ENOMEM;
  			goto mkdir_out;
  		}

  		mode &= ~current_umask();

  		rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
  				mode, NULL /* netfid */, pInfo, &oplock,

  				full_path, cifs_sb->local_nls,
  				cifs_sb->mnt_cifs_flags &

  					CIFS_MOUNT_MAP_SPECIAL_CHR);

  		if (rc == -EOPNOTSUPP) {
  			kfree(pInfo);
  			goto mkdir_retry_old;
  		} else if (rc) {

  			cFYI(1, "posix mkdir returned 0x%x", rc);

  			d_drop(direntry);
  		} else {

  			if (pInfo->Type == cpu_to_le32(-1)) {
  				/* no return info, go query for it */

  				kfree(pInfo);

  				goto mkdir_get_info;

  			}

  /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
  	to set uid/gid */

  			inc_nlink(inode);

  			cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);

  			cifs_fill_uniqueid(inode->i_sb, &fattr);

  			newinode = cifs_iget(inode->i_sb, &fattr);
  			if (!newinode) {

  				kfree(pInfo);

  				goto mkdir_get_info;

  			}

  			d_instantiate(direntry, newinode);

  #ifdef CONFIG_CIFS_DEBUG2

  			cFYI(1, "instantiated dentry %p %s to inode %p",
  				direntry, direntry->d_name.name, newinode);

  			if (newinode->i_nlink != 2)

  				cFYI(1, "unexpected number of links %d",
  					newinode->i_nlink);

  #endif

  		}
  		kfree(pInfo);
  		goto mkdir_out;

  	}

  mkdir_retry_old:

  	/* BB add setting the equivalent of mode via CreateX w/ACLs */

  	rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
  			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);

  	if (rc) {

  		cFYI(1, "cifs_mkdir returned 0x%x", rc);

  		d_drop(direntry);
  	} else {

  mkdir_get_info:

  		inc_nlink(inode);

  		if (pTcon->unix_ext)

  			rc = cifs_get_inode_info_unix(&newinode, full_path,

  						      inode->i_sb, xid);

  		else
  			rc = cifs_get_inode_info(&newinode, full_path, NULL,

  						 inode->i_sb, xid, NULL);

  		d_instantiate(direntry, newinode);

  		 /* setting nlink not necessary except in cases where we

  		  * failed to get it from the server or was set bogus */

  		if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))

  			set_nlink(direntry->d_inode, 2);

  		mode &= ~current_umask();

  		/* must turn on setgid bit if parent dir has it */
  		if (inode->i_mode & S_ISGID)
  			mode |= S_ISGID;

  		if (pTcon->unix_ext) {

  			struct cifs_unix_set_info_args args = {
  				.mode	= mode,
  				.ctime	= NO_CHANGE_64,
  				.atime	= NO_CHANGE_64,
  				.mtime	= NO_CHANGE_64,
  				.device	= 0,
  			};

  			if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {

  				args.uid = (__u64)current_fsuid();

  				if (inode->i_mode & S_ISGID)
  					args.gid = (__u64)inode->i_gid;
  				else

  					args.gid = (__u64)current_fsgid();

  			} else {

  				args.uid = NO_CHANGE_64;
  				args.gid = NO_CHANGE_64;

  			}

  			CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
  					       cifs_sb->local_nls,
  					       cifs_sb->mnt_cifs_flags &
  						CIFS_MOUNT_MAP_SPECIAL_CHR);

  		} else {

  			if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
  			    (mode & S_IWUGO) == 0) {
  				FILE_BASIC_INFO pInfo;

  				struct cifsInodeInfo *cifsInode;
  				u32 dosattrs;

  				memset(&pInfo, 0, sizeof(pInfo));

  				cifsInode = CIFS_I(newinode);
  				dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
  				pInfo.Attributes = cpu_to_le32(dosattrs);
  				tmprc = CIFSSMBSetPathInfo(xid, pTcon,
  						full_path, &pInfo,
  						cifs_sb->local_nls,

  						cifs_sb->mnt_cifs_flags &
  						CIFS_MOUNT_MAP_SPECIAL_CHR);

  				if (tmprc == 0)
  					cifsInode->cifsAttrs = dosattrs;

  			}

  			if (direntry->d_inode) {

  				if (cifs_sb->mnt_cifs_flags &
  				     CIFS_MOUNT_DYNPERM)
  					direntry->d_inode->i_mode =
  						(mode | S_IFDIR);

  				if (cifs_sb->mnt_cifs_flags &

  				     CIFS_MOUNT_SET_UID) {

  					direntry->d_inode->i_uid =

  						current_fsuid();

  					if (inode->i_mode & S_ISGID)
  						direntry->d_inode->i_gid =
  							inode->i_gid;
  					else
  						direntry->d_inode->i_gid =

  							current_fsgid();

  				}
  			}

  		}

  	}

  mkdir_out:

  	kfree(full_path);
  	FreeXid(xid);

  	cifs_put_tlink(tlink);

  	return rc;
  }
  
  int cifs_rmdir(struct inode *inode, struct dentry *direntry)
  {
  	int rc = 0;
  	int xid;
  	struct cifs_sb_info *cifs_sb;

  	struct tcon_link *tlink;

  	struct cifs_tcon *pTcon;

  	char *full_path = NULL;
  	struct cifsInodeInfo *cifsInode;

  	cFYI(1, "cifs_rmdir, inode = 0x%p", inode);

  
  	xid = GetXid();

  	full_path = build_path_from_dentry(direntry);

  	if (full_path == NULL) {

  		rc = -ENOMEM;

  		goto rmdir_exit;

  	}

  	cifs_sb = CIFS_SB(inode->i_sb);
  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink)) {
  		rc = PTR_ERR(tlink);
  		goto rmdir_exit;
  	}
  	pTcon = tlink_tcon(tlink);

  	rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
  			  cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);

  	cifs_put_tlink(tlink);

  
  	if (!rc) {

  		drop_nlink(inode);

  		spin_lock(&direntry->d_inode->i_lock);

  		i_size_write(direntry->d_inode, 0);

  		clear_nlink(direntry->d_inode);

  		spin_unlock(&direntry->d_inode->i_lock);

  	}
  
  	cifsInode = CIFS_I(direntry->d_inode);
  	cifsInode->time = 0;	/* force revalidate to go get info when
  				   needed */

  
  	cifsInode = CIFS_I(inode);
  	cifsInode->time = 0;	/* force revalidate to get parent dir info
  				   since cached search results now invalid */

  	direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
  		current_fs_time(inode->i_sb);

  rmdir_exit:

  	kfree(full_path);
  	FreeXid(xid);
  	return rc;
  }

  static int
  cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
  		struct dentry *to_dentry, const char *toPath)
  {
  	struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);

  	struct tcon_link *tlink;

  	struct cifs_tcon *pTcon;

  	__u16 srcfid;
  	int oplock, rc;

  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	pTcon = tlink_tcon(tlink);

  	/* try path-based rename first */
  	rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
  			   cifs_sb->mnt_cifs_flags &
  				CIFS_MOUNT_MAP_SPECIAL_CHR);
  
  	/*
  	 * don't bother with rename by filehandle unless file is busy and
  	 * source Note that cross directory moves do not work with
  	 * rename by filehandle to various Windows servers.
  	 */
  	if (rc == 0 || rc != -ETXTBSY)