// SPDX-License-Identifier: LGPL-2.1

  /*

   *

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

   *   Author(s): Steve French (sfrench@us.ibm.com)
   *

   */
  #include <linux/fs.h>

  #include <linux/stat.h>

  #include <linux/slab.h>

  #include <linux/pagemap.h>

  #include <linux/freezer.h>

  #include <linux/sched/signal.h>

  #include <linux/wait_bit.h>

  #include <linux/fiemap.h>

  #include <asm/div64.h>
  #include "cifsfs.h"
  #include "cifspdu.h"
  #include "cifsglob.h"
  #include "cifsproto.h"

  #include "smb2proto.h"

  #include "cifs_debug.h"
  #include "cifs_fs_sb.h"

  #include "cifs_unicode.h"

  #include "fscache.h"

  #include "fs_context.h"

  #include "cifs_ioctl.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->max_read <

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

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

  
  	if (inode->i_state & I_NEW) {

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

  		return;
  	}
  
  	/* don't bother with revalidation if we have an oplock */

  	if (CIFS_CACHE_READ(cifs_i)) {

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

  		return;
  	}
  
  	 /* revalidate if mtime or size have changed */

  	fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);

  	if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&

  	    cifs_i->server_eof == fattr->cf_eof) {

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

  		return;
  	}

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

  	set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);

  }

  /*
   * copy nlink to the inode, unless it wasn't provided.  Provide
   * sane values if we don't have an existing one and none was provided
   */
  static void
  cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
  {
  	/*
  	 * if we're in a situation where we can't trust what we
  	 * got from the server (readdir, some non-unix cases)
  	 * fake reasonable values
  	 */
  	if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
  		/* only provide fake values on a new inode */
  		if (inode->i_state & I_NEW) {
  			if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
  				set_nlink(inode, 2);
  			else
  				set_nlink(inode, 1);
  		}
  		return;
  	}
  
  	/* we trust the server, so update it */
  	set_nlink(inode, fattr->cf_nlink);
  }

  /* populate an inode with info from a cifs_fattr struct */

  int

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

  	if (!(inode->i_state & I_NEW) &&
  	    unlikely(inode_wrong_type(inode, fattr->cf_mode))) {
  		CIFS_I(inode)->time = 0; /* force reval */
  		return -ESTALE;
  	}

  	cifs_revalidate_cache(inode, fattr);

  	spin_lock(&inode->i_lock);

  	fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
  	fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
  	fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);

  	/* we do not want atime to be less than mtime, it broke some apps */

  	if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)

  		inode->i_atime = fattr->cf_mtime;
  	else
  		inode->i_atime = fattr->cf_atime;

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

  	inode->i_rdev = fattr->cf_rdev;

  	cifs_nlink_fattr_to_inode(inode, fattr);

  	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;

  	if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
  		set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
  	else
  		clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);

  	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.
  	 */

  	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;

  	if (inode->i_state & I_NEW)
  		cifs_set_ops(inode);

  	return 0;

  }

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

  	/* old POSIX extensions don't get create time */

  	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;

  		cifs_dbg(FYI, "unknown type %d
  ", le32_to_cpu(info->Type));

  		break;
  	}

  	fattr->cf_uid = cifs_sb->ctx->linux_uid;

  	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
  		u64 id = le64_to_cpu(info->Uid);

  		if (id < ((uid_t)-1)) {
  			kuid_t uid = make_kuid(&init_user_ns, id);
  			if (uid_valid(uid))
  				fattr->cf_uid = uid;
  		}

  	}
  	

  	fattr->cf_gid = cifs_sb->ctx->linux_gid;

  	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
  		u64 id = le64_to_cpu(info->Gid);

  		if (id < ((gid_t)-1)) {
  			kgid_t gid = make_kgid(&init_user_ns, id);
  			if (gid_valid(gid))
  				fattr->cf_gid = 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);

  	cifs_dbg(FYI, "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->ctx->linux_uid;
  	fattr->cf_gid = cifs_sb->ctx->linux_gid;

  	ktime_get_coarse_real_ts64(&fattr->cf_mtime);

  	fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;

  	fattr->cf_nlink = 2;

  	fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;

  }

  static int
  cifs_get_file_info_unix(struct file *filp)

  {
  	int rc;

  	unsigned int xid;

  	FILE_UNIX_BASIC_INFO find_data;
  	struct cifs_fattr fattr;

  	struct inode *inode = file_inode(filp);

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

  	rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.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;

  	} else
  		goto cifs_gfiunix_out;

  	rc = cifs_fattr_to_inode(inode, &fattr);

  
  cifs_gfiunix_out:

  	free_xid(xid);

  	return rc;
  }

  int cifs_get_inode_info_unix(struct inode **pinode,

  			     const unsigned char *full_path,

  			     struct super_block *sb, unsigned 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);

  	cifs_dbg(FYI, "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_remap(cifs_sb));

  	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 = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
  					     full_path);

  		if (tmprc)

  			cifs_dbg(FYI, "check_mf_symlink: %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 */

  
  		/* if uniqueid is different, return error */
  		if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
  		    CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {

  			CIFS_I(*pinode)->time = 0; /* force reval */

  			rc = -ESTALE;
  			goto cgiiu_exit;
  		}
  
  		/* if filetype is different, return error */

  		rc = cifs_fattr_to_inode(*pinode, &fattr);

  	}

  cgiiu_exit:

  	return rc;
  }

  static int

  cifs_sfu_type(struct cifs_fattr *fattr, const char *path,

  	      struct cifs_sb_info *cifs_sb, unsigned int xid)

  {
  	int rc;

  	__u32 oplock;

  	struct tcon_link *tlink;

  	struct cifs_tcon *tcon;

  	struct cifs_fid fid;
  	struct cifs_open_parms oparms;

  	struct cifs_io_parms io_parms = {0};

  	char buf[24];

  	unsigned int bytes_read;

  	char *pbuf;

  	int buf_type = CIFS_NO_BUFFER;

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

  	oparms.tcon = tcon;
  	oparms.cifs_sb = cifs_sb;
  	oparms.desired_access = GENERIC_READ;

  	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);

  	oparms.disposition = FILE_OPEN;
  	oparms.path = path;
  	oparms.fid = &fid;
  	oparms.reconnect = false;

  	if (tcon->ses->server->oplocks)
  		oplock = REQ_OPLOCK;
  	else
  		oplock = 0;
  	rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);

  	if (rc) {

  		cifs_dbg(FYI, "check sfu type of %s, open rc = %d
  ", path, rc);

  		cifs_put_tlink(tlink);
  		return rc;
  	}
  
  	/* Read header */

  	io_parms.netfid = fid.netfid;

  	io_parms.pid = current->tgid;
  	io_parms.tcon = tcon;
  	io_parms.offset = 0;
  	io_parms.length = 24;

  	rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
  					&bytes_read, &pbuf, &buf_type);

  	if ((rc == 0) && (bytes_read >= 8)) {
  		if (memcmp("IntxBLK", pbuf, 8) == 0) {
  			cifs_dbg(FYI, "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) {
  			cifs_dbg(FYI, "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) {
  			cifs_dbg(FYI, "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 */

  	}

  
  	tcon->ses->server->ops->close(xid, tcon, &fid);

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

  	if (tcon->ses->server->ops->query_all_EAs == NULL) {
  		cifs_put_tlink(tlink);
  		return -EOPNOTSUPP;
  	}
  
  	rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
  			"SETFILEBITS", ea_value, 4 /* size of buf */,

  			cifs_sb);

  	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;

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

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

  		cifs_dbg(FYI, "special mode bits 0%o
  ", mode);

  	}

  
  	return 0;

  #else
  	return -EOPNOTSUPP;
  #endif

  }

  /* Fill a cifs_fattr struct with info from POSIX info struct */
  static void
  smb311_posix_info_to_fattr(struct cifs_fattr *fattr, struct smb311_posix_qinfo *info,
  			   struct super_block *sb, bool adjust_tz, bool symlink)
  {
  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
  	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
  
  	memset(fattr, 0, sizeof(*fattr));
  
  	/* no fattr->flags to set */
  	fattr->cf_cifsattrs = le32_to_cpu(info->DosAttributes);
  	fattr->cf_uniqueid = le64_to_cpu(info->Inode);
  
  	if (info->LastAccessTime)
  		fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
  	else
  		ktime_get_coarse_real_ts64(&fattr->cf_atime);
  
  	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);
  
  	fattr->cf_nlink = le32_to_cpu(info->HardLinks);
  	fattr->cf_mode = (umode_t) le32_to_cpu(info->Mode);
  	/* The srv fs device id is overridden on network mount so setting rdev isn't needed here */
  	/* fattr->cf_rdev = le32_to_cpu(info->DeviceId); */
  
  	if (symlink) {
  		fattr->cf_mode |= S_IFLNK;
  		fattr->cf_dtype = DT_LNK;
  	} else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
  		fattr->cf_mode |= S_IFDIR;
  		fattr->cf_dtype = DT_DIR;
  	} else { /* file */
  		fattr->cf_mode |= S_IFREG;
  		fattr->cf_dtype = DT_REG;
  	}
  	/* else if reparse point ... TODO: add support for FIFO and blk dev; special file types */

  	fattr->cf_uid = cifs_sb->ctx->linux_uid; /* TODO: map uid and gid from SID */
  	fattr->cf_gid = cifs_sb->ctx->linux_gid;

  
  	cifs_dbg(FYI, "POSIX query info: mode 0x%x uniqueid 0x%llx nlink %d
  ",
  		fattr->cf_mode, fattr->cf_uniqueid, fattr->cf_nlink);
  }

  /* 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 super_block *sb, bool adjust_tz,

  		       bool symlink, u32 reparse_tag)

  {

  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

  	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
  		ktime_get_coarse_real_ts64(&fattr->cf_atime);

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

  	fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);

  	if (reparse_tag == IO_REPARSE_TAG_LX_SYMLINK) {

  		fattr->cf_mode |= S_IFLNK | cifs_sb->ctx->file_mode;

  		fattr->cf_dtype = DT_LNK;
  	} else if (reparse_tag == IO_REPARSE_TAG_LX_FIFO) {

  		fattr->cf_mode |= S_IFIFO | cifs_sb->ctx->file_mode;

  		fattr->cf_dtype = DT_FIFO;
  	} else if (reparse_tag == IO_REPARSE_TAG_AF_UNIX) {

  		fattr->cf_mode |= S_IFSOCK | cifs_sb->ctx->file_mode;

  		fattr->cf_dtype = DT_SOCK;
  	} else if (reparse_tag == IO_REPARSE_TAG_LX_CHR) {

  		fattr->cf_mode |= S_IFCHR | cifs_sb->ctx->file_mode;

  		fattr->cf_dtype = DT_CHR;
  	} else if (reparse_tag == IO_REPARSE_TAG_LX_BLK) {

  		fattr->cf_mode |= S_IFBLK | cifs_sb->ctx->file_mode;

  		fattr->cf_dtype = DT_BLK;
  	} else if (symlink) { /* TODO add more reparse tag checks */

  		fattr->cf_mode = S_IFLNK;
  		fattr->cf_dtype = DT_LNK;
  	} else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {

  		fattr->cf_mode = S_IFDIR | cifs_sb->ctx->dir_mode;

  		fattr->cf_dtype = DT_DIR;

  		/*
  		 * Server can return wrong NumberOfLinks value for directories
  		 * when Unix extensions are disabled - fake it.
  		 */

  		if (!tcon->unix_ext)
  			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;

  	} else {

  		fattr->cf_mode = S_IFREG | cifs_sb->ctx->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);

  		/*
  		 * Don't accept zero nlink from non-unix servers unless
  		 * delete is pending.  Instead mark it as unknown.
  		 */
  		if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
  		    !info->DeletePending) {

  			cifs_dbg(VFS, "bogus file nlink value %u
  ",
  				 fattr->cf_nlink);

  			fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;

  		}

  	}

  	fattr->cf_uid = cifs_sb->ctx->linux_uid;
  	fattr->cf_gid = cifs_sb->ctx->linux_gid;

  }

  static int
  cifs_get_file_info(struct file *filp)

  {
  	int rc;

  	unsigned int xid;

  	FILE_ALL_INFO find_data;
  	struct cifs_fattr fattr;

  	struct inode *inode = file_inode(filp);

  	struct cifsFileInfo *cfile = filp->private_data;

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

  	struct TCP_Server_Info *server = tcon->ses->server;
  
  	if (!server->ops->query_file_info)
  		return -ENOSYS;

  	xid = get_xid();

  	rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);

  	switch (rc) {
  	case 0:

  		/* TODO: add support to query reparse tag */

  		cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,

  				       false, 0 /* no reparse tag */);

  		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;

  		goto cgfi_exit;

  	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;

  	/* if filetype is different, return error */
  	rc = cifs_fattr_to_inode(inode, &fattr);

  cgfi_exit:

  	free_xid(xid);

  	return rc;
  }

  /* Simple function to return a 64 bit hash of string.  Rarely called */
  static __u64 simple_hashstr(const char *str)
  {

  	const __u64 hash_mult =  1125899906842597ULL; /* a big enough prime */

  	__u64 hash = 0;
  
  	while (*str)
  		hash = (hash + (__u64) *str++) * hash_mult;
  
  	return hash;
  }

  /**
   * cifs_backup_query_path_info - SMB1 fallback code to get ino
   *
   * Fallback code to get file metadata when we don't have access to

   * full_path (EACCES) and have backup creds.

   *

   * @xid:	transaction id used to identify original request in logs
   * @tcon:	information about the server share we have mounted
   * @sb:	the superblock stores info such as disk space available
   * @full_path:	name of the file we are getting the metadata for
   * @resp_buf:	will be set to cifs resp buf and needs to be freed with
   * 		cifs_buf_release() when done with @data
   * @data:	will be set to search info result buffer

   */
  static int
  cifs_backup_query_path_info(int xid,
  			    struct cifs_tcon *tcon,
  			    struct super_block *sb,
  			    const char *full_path,
  			    void **resp_buf,
  			    FILE_ALL_INFO **data)
  {
  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
  	struct cifs_search_info info = {0};
  	u16 flags;
  	int rc;
  
  	*resp_buf = NULL;
  	info.endOfSearch = false;
  	if (tcon->unix_ext)
  		info.info_level = SMB_FIND_FILE_UNIX;
  	else if ((tcon->ses->capabilities &
  		  tcon->ses->server->vals->cap_nt_find) == 0)
  		info.info_level = SMB_FIND_FILE_INFO_STANDARD;
  	else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
  		info.info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
  	else /* no srvino useful for fallback to some netapp */
  		info.info_level = SMB_FIND_FILE_DIRECTORY_INFO;
  
  	flags = CIFS_SEARCH_CLOSE_ALWAYS |
  		CIFS_SEARCH_CLOSE_AT_END |
  		CIFS_SEARCH_BACKUP_SEARCH;
  
  	rc = CIFSFindFirst(xid, tcon, full_path,
  			   cifs_sb, NULL, flags, &info, false);
  	if (rc)
  		return rc;
  
  	*resp_buf = (void *)info.ntwrk_buf_start;
  	*data = (FILE_ALL_INFO *)info.srch_entries_start;
  	return 0;
  }
  
  static void
  cifs_set_fattr_ino(int xid,
  		   struct cifs_tcon *tcon,
  		   struct super_block *sb,
  		   struct inode **inode,
  		   const char *full_path,
  		   FILE_ALL_INFO *data,
  		   struct cifs_fattr *fattr)
  {
  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
  	struct TCP_Server_Info *server = tcon->ses->server;
  	int rc;
  
  	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)) {
  		if (*inode)
  			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
  		else
  			fattr->cf_uniqueid = iunique(sb, ROOT_I);
  		return;
  	}
  
  	/*
  	 * If we have an inode pass a NULL tcon to ensure we don't
  	 * make a round trip to the server. This only works for SMB2+.
  	 */
  	rc = server->ops->get_srv_inum(xid,
  				       *inode ? NULL : tcon,
  				       cifs_sb, full_path,
  				       &fattr->cf_uniqueid,
  				       data);
  	if (rc) {
  		/*
  		 * If that fails reuse existing ino or generate one
  		 * and disable server ones
  		 */
  		if (*inode)
  			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
  		else {
  			fattr->cf_uniqueid = iunique(sb, ROOT_I);
  			cifs_autodisable_serverino(cifs_sb);
  		}
  		return;
  	}
  
  	/* If no errors, check for zero root inode (invalid) */
  	if (fattr->cf_uniqueid == 0 && strlen(full_path) == 0) {
  		cifs_dbg(FYI, "Invalid (0) inodenum
  ");
  		if (*inode) {
  			/* reuse */
  			fattr->cf_uniqueid = CIFS_I(*inode)->uniqueid;
  		} else {
  			/* make an ino by hashing the UNC */
  			fattr->cf_flags |= CIFS_FATTR_FAKE_ROOT_INO;
  			fattr->cf_uniqueid = simple_hashstr(tcon->treeName);
  		}
  	}
  }
  
  static inline bool is_inode_cache_good(struct inode *ino)
  {
  	return ino && CIFS_CACHE_READ(CIFS_I(ino)) && CIFS_I(ino)->time != 0;
  }

  int

  cifs_get_inode_info(struct inode **inode,
  		    const char *full_path,
  		    FILE_ALL_INFO *in_data,
  		    struct super_block *sb, int xid,

  		    const struct cifs_fid *fid)

  {

  	struct cifs_tcon *tcon;
  	struct TCP_Server_Info *server;

  	struct tcon_link *tlink;

  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);

  	bool adjust_tz = false;

  	struct cifs_fattr fattr = {0};

  	bool is_reparse_point = false;

  	FILE_ALL_INFO *data = in_data;
  	FILE_ALL_INFO *tmp_data = NULL;
  	void *smb1_backup_rsp_buf = NULL;
  	int rc = 0;
  	int tmprc = 0;

  	__u32 reparse_tag = 0;

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

  	tcon = tlink_tcon(tlink);
  	server = tcon->ses->server;

  	/*
  	 * 1. Fetch file metadata if not provided (data)
  	 */

  	if (!data) {
  		if (is_inode_cache_good(*inode)) {

  			cifs_dbg(FYI, "No need to revalidate cached inode sizes
  ");

  			goto out;

  		}

  		tmp_data = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
  		if (!tmp_data) {

  			rc = -ENOMEM;

  			goto out;

  		}

  		rc = server->ops->query_path_info(xid, tcon, cifs_sb,

  						 full_path, tmp_data,
  						 &adjust_tz, &is_reparse_point);

  		data = tmp_data;

  	}

  	/*
  	 * 2. Convert it to internal cifs metadata (fattr)
  	 */
  
  	switch (rc) {
  	case 0:

  		/*
  		 * If the file is a reparse point, it is more complicated
  		 * since we have to check if its reparse tag matches a known
  		 * special file type e.g. symlink or fifo or char etc.
  		 */
  		if ((le32_to_cpu(data->Attributes) & ATTR_REPARSE) &&
  		    server->ops->query_reparse_tag) {
  			rc = server->ops->query_reparse_tag(xid, tcon, cifs_sb,
  						full_path, &reparse_tag);
  			cifs_dbg(FYI, "reparse tag 0x%x
  ", reparse_tag);
  		}
  		cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
  				       is_reparse_point, reparse_tag);

  		break;
  	case -EREMOTE:
  		/* DFS link, no metadata available on this server */

  		cifs_create_dfs_fattr(&fattr, sb);

  		rc = 0;

  		break;
  	case -EACCES:

  		/*

  		 * perm errors, try again with backup flags if possible
  		 *
  		 * For SMB2 and later the backup intent flag
  		 * is already sent if needed on open and there
  		 * is no path based FindFirst operation to use
  		 * to retry with

  		 */

  		if (backup_cred(cifs_sb) && is_smb1_server(server)) {
  			/* for easier reading */
  			FILE_DIRECTORY_INFO *fdi;
  			SEARCH_ID_FULL_DIR_INFO *si;
  
  			rc = cifs_backup_query_path_info(xid, tcon, sb,
  							 full_path,
  							 &smb1_backup_rsp_buf,
  							 &data);
  			if (rc)
  				goto out;
  
  			fdi = (FILE_DIRECTORY_INFO *)data;
  			si = (SEARCH_ID_FULL_DIR_INFO *)data;
  
  			cifs_dir_info_to_fattr(&fattr, fdi, cifs_sb);
  			fattr.cf_uniqueid = le64_to_cpu(si->UniqueId);
  			/* uniqueid set, skip get inum step */
  			goto handle_mnt_opt;
  		} else {
  			/* nothing we can do, bail out */
  			goto out;

  		}

  		break;
  	default:
  		cifs_dbg(FYI, "%s: unhandled err rc %d
  ", __func__, rc);
  		goto out;
  	}

  	/*
  	 * 3. Get or update inode number (fattr.cf_uniqueid)
  	 */
  
  	cifs_set_fattr_ino(xid, tcon, sb, inode, full_path, data, &fattr);

  	/*

  	 * 4. Tweak fattr based on mount options

  	 */

  handle_mnt_opt:

  	/* 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)

  			cifs_dbg(FYI, "cifs_sfu_type failed: %d
  ", tmprc);

  	}

  	/* fill in 0777 bits from ACL */

  	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
  		rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
  				       full_path, fid);

  		if (rc == -EREMOTE)
  			rc = 0;

  		if (rc) {
  			cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d
  ",

  				 __func__, rc);
  			goto out;

  		}
  	} else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
  		rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,

  				       full_path, fid);

  		if (rc == -EREMOTE)
  			rc = 0;

  		if (rc) {

  			cifs_dbg(FYI, "%s: Getting ACL failed with error: %d
  ",
  				 __func__, rc);

  			goto out;

  		}

  	}

  	/* 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 = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
  					 full_path);

  		if (tmprc)

  			cifs_dbg(FYI, "check_mf_symlink: %d
  ", tmprc);

  	}

  	/*
  	 * 5. Update inode with final fattr data
  	 */

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

  			rc = -ENOMEM;
  	} else {

  		/* we already have inode, update it */

  		/* if uniqueid is different, return error */
  		if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
  		    CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {

  			CIFS_I(*inode)->time = 0; /* force reval */

  			rc = -ESTALE;

  			goto out;

  		}

  		/* if filetype is different, return error */

  		rc = cifs_fattr_to_inode(*inode, &fattr);

  	}

  out:
  	cifs_buf_release(smb1_backup_rsp_buf);

  	cifs_put_tlink(tlink);

  	kfree(tmp_data);

  	return rc;
  }

  int
  smb311_posix_get_inode_info(struct inode **inode,
  		    const char *full_path,
  		    struct super_block *sb, unsigned int xid)
  {
  	struct cifs_tcon *tcon;

  	struct tcon_link *tlink;
  	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
  	bool adjust_tz = false;
  	struct cifs_fattr fattr = {0};
  	bool symlink = false;
  	struct smb311_posix_qinfo *data = NULL;
  	int rc = 0;
  	int tmprc = 0;
  
  	tlink = cifs_sb_tlink(cifs_sb);
  	if (IS_ERR(tlink))
  		return PTR_ERR(tlink);
  	tcon = tlink_tcon(tlink);

  
  	/*
  	 * 1. Fetch file metadata
  	 */
  
  	if (is_inode_cache_good(*inode)) {
  		cifs_dbg(FYI, "No need to revalidate cached inode sizes
  ");
  		goto out;
  	}
  	data = kmalloc(sizeof(struct smb311_posix_qinfo), GFP_KERNEL);
  	if (!data) {
  		rc = -ENOMEM;
  		goto out;
  	}
  
  	rc = smb311_posix_query_path_info(xid, tcon, cifs_sb,
  						  full_path, data,
  						  &adjust_tz, &symlink);
  
  	/*
  	 * 2. Convert it to internal cifs metadata (fattr)
  	 */
  
  	switch (rc) {
  	case 0:
  		smb311_posix_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
  		break;
  	case -EREMOTE:
  		/* DFS link, no metadata available on this server */
  		cifs_create_dfs_fattr(&fattr, sb);
  		rc = 0;
  		break;
  	case -EACCES:
  		/*
  		 * For SMB2 and later the backup intent flag
  		 * is already sent if needed on open and there
  		 * is no path based FindFirst operation to use
  		 * to retry with so nothing we can do, bail out
  		 */
  		goto out;
  	default:
  		cifs_dbg(FYI, "%s: unhandled err rc %d
  ", __func__, rc);
  		goto out;
  	}
  
  
  	/*

  	 * 3. Tweak fattr based on mount options

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

  	 * 4. Update inode with final fattr data

  	 */
  
  	if (!*inode) {
  		*inode = cifs_iget(sb, &fattr);
  		if (!*inode)
  			rc = -ENOMEM;
  	} else {
  		/* we already have inode, update it */
  
  		/* if uniqueid is different, return error */
  		if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
  		    CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
  			CIFS_I(*inode)->time = 0; /* force reval */
  			rc = -ESTALE;
  			goto out;
  		}
  
  		/* if filetype is different, return error */

  		rc = cifs_fattr_to_inode(*inode, &fattr);

  	}
  out:
  	cifs_put_tlink(tlink);
  	kfree(data);
  	return rc;
  }

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

  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_wrong_type(inode, fattr->cf_mode))

  		return 0;

  	/* if it's not a directory or has no dentries, then flag it */

  	if (S_ISDIR(inode->i_mode) && !hlist_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);

  	hlist_for_each_entry(dentry, &inode->i_dentry, d_u.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:

  	cifs_dbg(FYI, "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;
  			}

  		}

  		/* can't fail - see cifs_find_inode() */

  		cifs_fattr_to_inode(inode, fattr);

  		if (sb->s_flags & SB_NOATIME)

  			inode->i_flags |= S_NOATIME | S_NOCMTIME;
  		if (inode->i_state & I_NEW) {
  			inode->i_ino = hash;

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

  {

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

  	char *path = NULL;
  	int len;
  
  	if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
  	    && cifs_sb->prepath) {
  		len = strlen(cifs_sb->prepath);
  		path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
  		if (path == NULL)
  			return ERR_PTR(-ENOMEM);
  		path[0] = '/';
  		memcpy(path+1, cifs_sb->prepath, len);
  	} else {
  		path = kstrdup("", GFP_KERNEL);
  		if (path == NULL)
  			return ERR_PTR(-ENOMEM);
  	}

  	xid = get_xid();

  	if (tcon->unix_ext) {

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

  		/* some servers mistakenly claim POSIX support */
  		if (rc != -EOPNOTSUPP)
  			goto iget_no_retry;

  		cifs_dbg(VFS, "server does not support POSIX extensions
  ");

  		tcon->unix_ext = false;
  	}

  	convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));

  	if (tcon->posix_extensions)
  		rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
  	else
  		rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);

  iget_no_retry:

  	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->pipe) {

  		cifs_dbg(FYI, "ipc connection - fake read inode
  ");

  		spin_lock(&inode->i_lock);

  		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->ctx->linux_uid;
  		inode->i_gid = cifs_sb->ctx->linux_gid;

  		spin_unlock(&inode->i_lock);

  	} else if (rc) {

  		iget_failed(inode);

  		inode = ERR_PTR(rc);

  	}

  out:

  	kfree(path);

  	free_xid(xid);

  	return inode;

  }

  int

  cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,

  		   const char *full_path, __u32 dosattr)

  {

  	bool set_time = false;

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

  	struct TCP_Server_Info *server;

  	FILE_BASIC_INFO	info_buf;

  	if (attrs == NULL)
  		return -EINVAL;

  	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
  	if (!server->ops->set_file_info)
  		return -ENOSYS;

  	info_buf.Pad = 0;

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

  		cifs_dbg(FYI, "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);

  	return server->ops->set_file_info(inode, full_path, &info_buf, xid);

  }

  /*

   * 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.
   */

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

  {
  	int oplock = 0;
  	int rc;

  	struct cifs_fid fid;
  	struct cifs_open_parms oparms;

  	struct inode *inode = d_inode(dentry);

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

  	/*
  	 * We cannot rename the file if the server doesn't support
  	 * CAP_INFOLEVEL_PASSTHRU
  	 */
  	if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
  		rc = -EBUSY;
  		goto out;
  	}

  	oparms.tcon = tcon;
  	oparms.cifs_sb = cifs_sb;
  	oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;

  	oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);

  	oparms.disposition = FILE_OPEN;
  	oparms.path = full_path;
  	oparms.fid = &fid;
  	oparms.reconnect = false;
  
  	rc = CIFS_open(xid, &oparms, &oplock, NULL);

  	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, fid.netfid,

  					current->tgid);
  		/* although we would like to mark the file hidden
   		   if that fails we will still try to rename it */

  		if (!rc)

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

  	}

  	/* rename the file */

  	rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
  				   cifs_sb->local_nls,

  				   cifs_remap(cifs_sb));

  	if (rc != 0) {

  		rc = -EBUSY;

  		goto undo_setattr;
  	}

  	/* try to set DELETE_ON_CLOSE */

  	if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {

  		rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.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 = -EBUSY;

  			goto undo_rename;
  		}

  		set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);

  	}

  out_close:

  	CIFSSMBClose(xid, tcon, fid.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, fid.netfid, dentry->d_name.name,

  				cifs_sb->local_nls, cifs_remap(cifs_sb));

  undo_setattr:
  	if (dosattr != origattr) {
  		info_buf->Attributes = cpu_to_le32(origattr);

  		if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,

  					current->tgid))
  			cifsInode->cifsAttrs = origattr;
  	}
  
  	goto out_close;

  }

  /* copied from fs/nfs/dir.c with small changes */
  static void
  cifs_drop_nlink(struct inode *inode)
  {
  	spin_lock(&inode->i_lock);
  	if (inode->i_nlink > 0)
  		drop_nlink(inode);
  	spin_unlock(&inode->i_lock);
  }

  
  /*

   * If d_inode(dentry) 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 EACCES
   * but will return the EACCES 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;

  	unsigned int xid;

  	const char *full_path;
  	void *page;

  	struct inode *inode = d_inode(dentry);

  	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 TCP_Server_Info *server;

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

  	cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p
  ", dir, dentry);

  	if (unlikely(cifs_forced_shutdown(cifs_sb)))
  		return -EIO;

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

  	server = tcon->ses->server;

  	xid = get_xid();

  	page = alloc_dentry_path();

  	if (tcon->nodelete) {
  		rc = -EACCES;
  		goto unlink_out;
  	}

  	/* 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, page);
  	if (IS_ERR(full_path)) {
  		rc = PTR_ERR(full_path);

  		goto unlink_out;

  	}

  	cifs_close_deferred_file_under_dentry(tcon, full_path);

  	if (cap_unix(tcon->ses) && (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_remap(cifs_sb));

  		cifs_dbg(FYI, "posix del rc %d
  ", rc);

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

  retry_std_delete:

  	if (!server->ops->unlink) {
  		rc = -ENOSYS;
  		goto psx_del_no_retry;
  	}
  
  	rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);

  psx_del_no_retry:

  	if (!rc) {

  		if (inode)

  			cifs_drop_nlink(inode);

  	} else if (rc == -ENOENT) {

  		d_drop(dentry);

  	} else if (rc == -EBUSY) {

  		if (server->ops->rename_pending_delete) {
  			rc = server->ops->rename_pending_delete(full_path,
  								dentry, xid);
  			if (rc == 0)
  				cifs_drop_nlink(inode);
  		}