root/fs/cifs/inode.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. cifs_set_ops
  2. cifs_revalidate_cache
  3. cifs_nlink_fattr_to_inode
  4. cifs_fattr_to_inode
  5. cifs_fill_uniqueid
  6. cifs_unix_basic_to_fattr
  7. cifs_create_dfs_fattr
  8. cifs_get_file_info_unix
  9. cifs_get_inode_info_unix
  10. cifs_sfu_type
  11. cifs_sfu_mode
  12. cifs_all_info_to_fattr
  13. cifs_get_file_info
  14. simple_hashstr
  15. cifs_get_inode_info
  16. cifs_find_inode
  17. cifs_init_inode
  18. inode_has_hashed_dentries
  19. cifs_iget
  20. cifs_root_iget
  21. cifs_set_file_info
  22. cifs_rename_pending_delete
  23. cifs_drop_nlink
  24. cifs_unlink
  25. cifs_mkdir_qinfo
  26. cifs_posix_mkdir
  27. cifs_mkdir
  28. cifs_rmdir
  29. cifs_do_rename
  30. cifs_rename2
  31. cifs_inode_needs_reval
  32. cifs_invalidate_mapping
  33. cifs_wait_bit_killable
  34. cifs_revalidate_mapping
  35. cifs_zap_mapping
  36. cifs_revalidate_file_attr
  37. cifs_revalidate_dentry_attr
  38. cifs_revalidate_file
  39. cifs_revalidate_dentry
  40. cifs_getattr
  41. cifs_fiemap
  42. cifs_truncate_page
  43. cifs_setsize
  44. cifs_set_file_size
  45. cifs_setattr_unix
  46. cifs_setattr_nounix
  47. cifs_setattr
  48. cifs_delete_inode

   1 /*
   2  *   fs/cifs/inode.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2010
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/stat.h>
  23 #include <linux/slab.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/freezer.h>
  26 #include <linux/sched/signal.h>
  27 #include <linux/wait_bit.h>
  28 
  29 #include <asm/div64.h>
  30 #include "cifsfs.h"
  31 #include "cifspdu.h"
  32 #include "cifsglob.h"
  33 #include "cifsproto.h"
  34 #include "cifs_debug.h"
  35 #include "cifs_fs_sb.h"
  36 #include "cifs_unicode.h"
  37 #include "fscache.h"
  38 
  39 
  40 static void cifs_set_ops(struct inode *inode)
  41 {
  42         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  43 
  44         switch (inode->i_mode & S_IFMT) {
  45         case S_IFREG:
  46                 inode->i_op = &cifs_file_inode_ops;
  47                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  48                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  49                                 inode->i_fop = &cifs_file_direct_nobrl_ops;
  50                         else
  51                                 inode->i_fop = &cifs_file_direct_ops;
  52                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  53                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  54                                 inode->i_fop = &cifs_file_strict_nobrl_ops;
  55                         else
  56                                 inode->i_fop = &cifs_file_strict_ops;
  57                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  58                         inode->i_fop = &cifs_file_nobrl_ops;
  59                 else { /* not direct, send byte range locks */
  60                         inode->i_fop = &cifs_file_ops;
  61                 }
  62 
  63                 /* check if server can support readpages */
  64                 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
  65                                 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
  66                         inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  67                 else
  68                         inode->i_data.a_ops = &cifs_addr_ops;
  69                 break;
  70         case S_IFDIR:
  71 #ifdef CONFIG_CIFS_DFS_UPCALL
  72                 if (IS_AUTOMOUNT(inode)) {
  73                         inode->i_op = &cifs_dfs_referral_inode_operations;
  74                 } else {
  75 #else /* NO DFS support, treat as a directory */
  76                 {
  77 #endif
  78                         inode->i_op = &cifs_dir_inode_ops;
  79                         inode->i_fop = &cifs_dir_ops;
  80                 }
  81                 break;
  82         case S_IFLNK:
  83                 inode->i_op = &cifs_symlink_inode_ops;
  84                 break;
  85         default:
  86                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
  87                 break;
  88         }
  89 }
  90 
  91 /* check inode attributes against fattr. If they don't match, tag the
  92  * inode for cache invalidation
  93  */
  94 static void
  95 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
  96 {
  97         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
  98 
  99         cifs_dbg(FYI, "%s: revalidating inode %llu\n",
 100                  __func__, cifs_i->uniqueid);
 101 
 102         if (inode->i_state & I_NEW) {
 103                 cifs_dbg(FYI, "%s: inode %llu is new\n",
 104                          __func__, cifs_i->uniqueid);
 105                 return;
 106         }
 107 
 108         /* don't bother with revalidation if we have an oplock */
 109         if (CIFS_CACHE_READ(cifs_i)) {
 110                 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
 111                          __func__, cifs_i->uniqueid);
 112                 return;
 113         }
 114 
 115          /* revalidate if mtime or size have changed */
 116         if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
 117             cifs_i->server_eof == fattr->cf_eof) {
 118                 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
 119                          __func__, cifs_i->uniqueid);
 120                 return;
 121         }
 122 
 123         cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 124                  __func__, cifs_i->uniqueid);
 125         set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
 126 }
 127 
 128 /*
 129  * copy nlink to the inode, unless it wasn't provided.  Provide
 130  * sane values if we don't have an existing one and none was provided
 131  */
 132 static void
 133 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 134 {
 135         /*
 136          * if we're in a situation where we can't trust what we
 137          * got from the server (readdir, some non-unix cases)
 138          * fake reasonable values
 139          */
 140         if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
 141                 /* only provide fake values on a new inode */
 142                 if (inode->i_state & I_NEW) {
 143                         if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
 144                                 set_nlink(inode, 2);
 145                         else
 146                                 set_nlink(inode, 1);
 147                 }
 148                 return;
 149         }
 150 
 151         /* we trust the server, so update it */
 152         set_nlink(inode, fattr->cf_nlink);
 153 }
 154 
 155 /* populate an inode with info from a cifs_fattr struct */
 156 void
 157 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 158 {
 159         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 160         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 161 
 162         cifs_revalidate_cache(inode, fattr);
 163 
 164         spin_lock(&inode->i_lock);
 165         /* we do not want atime to be less than mtime, it broke some apps */
 166         if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
 167                 inode->i_atime = fattr->cf_mtime;
 168         else
 169                 inode->i_atime = fattr->cf_atime;
 170         inode->i_mtime = fattr->cf_mtime;
 171         inode->i_ctime = fattr->cf_ctime;
 172         inode->i_rdev = fattr->cf_rdev;
 173         cifs_nlink_fattr_to_inode(inode, fattr);
 174         inode->i_uid = fattr->cf_uid;
 175         inode->i_gid = fattr->cf_gid;
 176 
 177         /* if dynperm is set, don't clobber existing mode */
 178         if (inode->i_state & I_NEW ||
 179             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
 180                 inode->i_mode = fattr->cf_mode;
 181 
 182         cifs_i->cifsAttrs = fattr->cf_cifsattrs;
 183 
 184         if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
 185                 cifs_i->time = 0;
 186         else
 187                 cifs_i->time = jiffies;
 188 
 189         if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
 190                 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 191         else
 192                 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 193 
 194         cifs_i->server_eof = fattr->cf_eof;
 195         /*
 196          * Can't safely change the file size here if the client is writing to
 197          * it due to potential races.
 198          */
 199         if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
 200                 i_size_write(inode, fattr->cf_eof);
 201 
 202                 /*
 203                  * i_blocks is not related to (i_size / i_blksize),
 204                  * but instead 512 byte (2**9) size is required for
 205                  * calculating num blocks.
 206                  */
 207                 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
 208         }
 209         spin_unlock(&inode->i_lock);
 210 
 211         if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
 212                 inode->i_flags |= S_AUTOMOUNT;
 213         if (inode->i_state & I_NEW)
 214                 cifs_set_ops(inode);
 215 }
 216 
 217 void
 218 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
 219 {
 220         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 221 
 222         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 223                 return;
 224 
 225         fattr->cf_uniqueid = iunique(sb, ROOT_I);
 226 }
 227 
 228 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
 229 void
 230 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
 231                          struct cifs_sb_info *cifs_sb)
 232 {
 233         memset(fattr, 0, sizeof(*fattr));
 234         fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
 235         fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
 236         fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 237 
 238         fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 239         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
 240         fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
 241         /* old POSIX extensions don't get create time */
 242 
 243         fattr->cf_mode = le64_to_cpu(info->Permissions);
 244 
 245         /*
 246          * Since we set the inode type below we need to mask off
 247          * to avoid strange results if bits set above.
 248          */
 249         fattr->cf_mode &= ~S_IFMT;
 250         switch (le32_to_cpu(info->Type)) {
 251         case UNIX_FILE:
 252                 fattr->cf_mode |= S_IFREG;
 253                 fattr->cf_dtype = DT_REG;
 254                 break;
 255         case UNIX_SYMLINK:
 256                 fattr->cf_mode |= S_IFLNK;
 257                 fattr->cf_dtype = DT_LNK;
 258                 break;
 259         case UNIX_DIR:
 260                 fattr->cf_mode |= S_IFDIR;
 261                 fattr->cf_dtype = DT_DIR;
 262                 break;
 263         case UNIX_CHARDEV:
 264                 fattr->cf_mode |= S_IFCHR;
 265                 fattr->cf_dtype = DT_CHR;
 266                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 267                                        le64_to_cpu(info->DevMinor) & MINORMASK);
 268                 break;
 269         case UNIX_BLOCKDEV:
 270                 fattr->cf_mode |= S_IFBLK;
 271                 fattr->cf_dtype = DT_BLK;
 272                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 273                                        le64_to_cpu(info->DevMinor) & MINORMASK);
 274                 break;
 275         case UNIX_FIFO:
 276                 fattr->cf_mode |= S_IFIFO;
 277                 fattr->cf_dtype = DT_FIFO;
 278                 break;
 279         case UNIX_SOCKET:
 280                 fattr->cf_mode |= S_IFSOCK;
 281                 fattr->cf_dtype = DT_SOCK;
 282                 break;
 283         default:
 284                 /* safest to call it a file if we do not know */
 285                 fattr->cf_mode |= S_IFREG;
 286                 fattr->cf_dtype = DT_REG;
 287                 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
 288                 break;
 289         }
 290 
 291         fattr->cf_uid = cifs_sb->mnt_uid;
 292         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
 293                 u64 id = le64_to_cpu(info->Uid);
 294                 if (id < ((uid_t)-1)) {
 295                         kuid_t uid = make_kuid(&init_user_ns, id);
 296                         if (uid_valid(uid))
 297                                 fattr->cf_uid = uid;
 298                 }
 299         }
 300         
 301         fattr->cf_gid = cifs_sb->mnt_gid;
 302         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
 303                 u64 id = le64_to_cpu(info->Gid);
 304                 if (id < ((gid_t)-1)) {
 305                         kgid_t gid = make_kgid(&init_user_ns, id);
 306                         if (gid_valid(gid))
 307                                 fattr->cf_gid = gid;
 308                 }
 309         }
 310 
 311         fattr->cf_nlink = le64_to_cpu(info->Nlinks);
 312 }
 313 
 314 /*
 315  * Fill a cifs_fattr struct with fake inode info.
 316  *
 317  * Needed to setup cifs_fattr data for the directory which is the
 318  * junction to the new submount (ie to setup the fake directory
 319  * which represents a DFS referral).
 320  */
 321 static void
 322 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
 323 {
 324         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 325 
 326         cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
 327 
 328         memset(fattr, 0, sizeof(*fattr));
 329         fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
 330         fattr->cf_uid = cifs_sb->mnt_uid;
 331         fattr->cf_gid = cifs_sb->mnt_gid;
 332         ktime_get_real_ts64(&fattr->cf_mtime);
 333         fattr->cf_mtime = timespec64_trunc(fattr->cf_mtime, sb->s_time_gran);
 334         fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
 335         fattr->cf_nlink = 2;
 336         fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
 337 }
 338 
 339 static int
 340 cifs_get_file_info_unix(struct file *filp)
 341 {
 342         int rc;
 343         unsigned int xid;
 344         FILE_UNIX_BASIC_INFO find_data;
 345         struct cifs_fattr fattr;
 346         struct inode *inode = file_inode(filp);
 347         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 348         struct cifsFileInfo *cfile = filp->private_data;
 349         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 350 
 351         xid = get_xid();
 352         rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
 353         if (!rc) {
 354                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 355         } else if (rc == -EREMOTE) {
 356                 cifs_create_dfs_fattr(&fattr, inode->i_sb);
 357                 rc = 0;
 358         }
 359 
 360         cifs_fattr_to_inode(inode, &fattr);
 361         free_xid(xid);
 362         return rc;
 363 }
 364 
 365 int cifs_get_inode_info_unix(struct inode **pinode,
 366                              const unsigned char *full_path,
 367                              struct super_block *sb, unsigned int xid)
 368 {
 369         int rc;
 370         FILE_UNIX_BASIC_INFO find_data;
 371         struct cifs_fattr fattr;
 372         struct cifs_tcon *tcon;
 373         struct tcon_link *tlink;
 374         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 375 
 376         cifs_dbg(FYI, "Getting info on %s\n", full_path);
 377 
 378         tlink = cifs_sb_tlink(cifs_sb);
 379         if (IS_ERR(tlink))
 380                 return PTR_ERR(tlink);
 381         tcon = tlink_tcon(tlink);
 382 
 383         /* could have done a find first instead but this returns more info */
 384         rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
 385                                   cifs_sb->local_nls, cifs_remap(cifs_sb));
 386         cifs_put_tlink(tlink);
 387 
 388         if (!rc) {
 389                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 390         } else if (rc == -EREMOTE) {
 391                 cifs_create_dfs_fattr(&fattr, sb);
 392                 rc = 0;
 393         } else {
 394                 return rc;
 395         }
 396 
 397         /* check for Minshall+French symlinks */
 398         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 399                 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
 400                                              full_path);
 401                 if (tmprc)
 402                         cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
 403         }
 404 
 405         if (*pinode == NULL) {
 406                 /* get new inode */
 407                 cifs_fill_uniqueid(sb, &fattr);
 408                 *pinode = cifs_iget(sb, &fattr);
 409                 if (!*pinode)
 410                         rc = -ENOMEM;
 411         } else {
 412                 /* we already have inode, update it */
 413 
 414                 /* if uniqueid is different, return error */
 415                 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 416                     CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
 417                         CIFS_I(*pinode)->time = 0; /* force reval */
 418                         rc = -ESTALE;
 419                         goto cgiiu_exit;
 420                 }
 421 
 422                 /* if filetype is different, return error */
 423                 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
 424                     (fattr.cf_mode & S_IFMT))) {
 425                         CIFS_I(*pinode)->time = 0; /* force reval */
 426                         rc = -ESTALE;
 427                         goto cgiiu_exit;
 428                 }
 429 
 430                 cifs_fattr_to_inode(*pinode, &fattr);
 431         }
 432 
 433 cgiiu_exit:
 434         return rc;
 435 }
 436 
 437 static int
 438 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
 439               struct cifs_sb_info *cifs_sb, unsigned int xid)
 440 {
 441         int rc;
 442         __u32 oplock;
 443         struct tcon_link *tlink;
 444         struct cifs_tcon *tcon;
 445         struct cifs_fid fid;
 446         struct cifs_open_parms oparms;
 447         struct cifs_io_parms io_parms;
 448         char buf[24];
 449         unsigned int bytes_read;
 450         char *pbuf;
 451         int buf_type = CIFS_NO_BUFFER;
 452 
 453         pbuf = buf;
 454 
 455         fattr->cf_mode &= ~S_IFMT;
 456 
 457         if (fattr->cf_eof == 0) {
 458                 fattr->cf_mode |= S_IFIFO;
 459                 fattr->cf_dtype = DT_FIFO;
 460                 return 0;
 461         } else if (fattr->cf_eof < 8) {
 462                 fattr->cf_mode |= S_IFREG;
 463                 fattr->cf_dtype = DT_REG;
 464                 return -EINVAL;  /* EOPNOTSUPP? */
 465         }
 466 
 467         tlink = cifs_sb_tlink(cifs_sb);
 468         if (IS_ERR(tlink))
 469                 return PTR_ERR(tlink);
 470         tcon = tlink_tcon(tlink);
 471 
 472         oparms.tcon = tcon;
 473         oparms.cifs_sb = cifs_sb;
 474         oparms.desired_access = GENERIC_READ;
 475         oparms.create_options = CREATE_NOT_DIR;
 476         if (backup_cred(cifs_sb))
 477                 oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
 478         oparms.disposition = FILE_OPEN;
 479         oparms.path = path;
 480         oparms.fid = &fid;
 481         oparms.reconnect = false;
 482 
 483         if (tcon->ses->server->oplocks)
 484                 oplock = REQ_OPLOCK;
 485         else
 486                 oplock = 0;
 487         rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
 488         if (rc) {
 489                 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
 490                 cifs_put_tlink(tlink);
 491                 return rc;
 492         }
 493 
 494         /* Read header */
 495         io_parms.netfid = fid.netfid;
 496         io_parms.pid = current->tgid;
 497         io_parms.tcon = tcon;
 498         io_parms.offset = 0;
 499         io_parms.length = 24;
 500 
 501         rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
 502                                         &bytes_read, &pbuf, &buf_type);
 503         if ((rc == 0) && (bytes_read >= 8)) {
 504                 if (memcmp("IntxBLK", pbuf, 8) == 0) {
 505                         cifs_dbg(FYI, "Block device\n");
 506                         fattr->cf_mode |= S_IFBLK;
 507                         fattr->cf_dtype = DT_BLK;
 508                         if (bytes_read == 24) {
 509                                 /* we have enough to decode dev num */
 510                                 __u64 mjr; /* major */
 511                                 __u64 mnr; /* minor */
 512                                 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 513                                 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 514                                 fattr->cf_rdev = MKDEV(mjr, mnr);
 515                         }
 516                 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
 517                         cifs_dbg(FYI, "Char device\n");
 518                         fattr->cf_mode |= S_IFCHR;
 519                         fattr->cf_dtype = DT_CHR;
 520                         if (bytes_read == 24) {
 521                                 /* we have enough to decode dev num */
 522                                 __u64 mjr; /* major */
 523                                 __u64 mnr; /* minor */
 524                                 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 525                                 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 526                                 fattr->cf_rdev = MKDEV(mjr, mnr);
 527                         }
 528                 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
 529                         cifs_dbg(FYI, "Symlink\n");
 530                         fattr->cf_mode |= S_IFLNK;
 531                         fattr->cf_dtype = DT_LNK;
 532                 } else {
 533                         fattr->cf_mode |= S_IFREG; /* file? */
 534                         fattr->cf_dtype = DT_REG;
 535                         rc = -EOPNOTSUPP;
 536                 }
 537         } else {
 538                 fattr->cf_mode |= S_IFREG; /* then it is a file */
 539                 fattr->cf_dtype = DT_REG;
 540                 rc = -EOPNOTSUPP; /* or some unknown SFU type */
 541         }
 542 
 543         tcon->ses->server->ops->close(xid, tcon, &fid);
 544         cifs_put_tlink(tlink);
 545         return rc;
 546 }
 547 
 548 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
 549 
 550 /*
 551  * Fetch mode bits as provided by SFU.
 552  *
 553  * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
 554  */
 555 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
 556                          struct cifs_sb_info *cifs_sb, unsigned int xid)
 557 {
 558 #ifdef CONFIG_CIFS_XATTR
 559         ssize_t rc;
 560         char ea_value[4];
 561         __u32 mode;
 562         struct tcon_link *tlink;
 563         struct cifs_tcon *tcon;
 564 
 565         tlink = cifs_sb_tlink(cifs_sb);
 566         if (IS_ERR(tlink))
 567                 return PTR_ERR(tlink);
 568         tcon = tlink_tcon(tlink);
 569 
 570         if (tcon->ses->server->ops->query_all_EAs == NULL) {
 571                 cifs_put_tlink(tlink);
 572                 return -EOPNOTSUPP;
 573         }
 574 
 575         rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
 576                         "SETFILEBITS", ea_value, 4 /* size of buf */,
 577                         cifs_sb);
 578         cifs_put_tlink(tlink);
 579         if (rc < 0)
 580                 return (int)rc;
 581         else if (rc > 3) {
 582                 mode = le32_to_cpu(*((__le32 *)ea_value));
 583                 fattr->cf_mode &= ~SFBITS_MASK;
 584                 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
 585                          mode, fattr->cf_mode);
 586                 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
 587                 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
 588         }
 589 
 590         return 0;
 591 #else
 592         return -EOPNOTSUPP;
 593 #endif
 594 }
 595 
 596 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
 597 static void
 598 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
 599                        struct super_block *sb, bool adjust_tz,
 600                        bool symlink)
 601 {
 602         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 603         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 604 
 605         memset(fattr, 0, sizeof(*fattr));
 606         fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
 607         if (info->DeletePending)
 608                 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
 609 
 610         if (info->LastAccessTime)
 611                 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 612         else {
 613                 ktime_get_real_ts64(&fattr->cf_atime);
 614                 fattr->cf_atime = timespec64_trunc(fattr->cf_atime, sb->s_time_gran);
 615         }
 616 
 617         fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
 618         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
 619 
 620         if (adjust_tz) {
 621                 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
 622                 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
 623         }
 624 
 625         fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 626         fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
 627         fattr->cf_createtime = le64_to_cpu(info->CreationTime);
 628 
 629         fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
 630 
 631         if (symlink) {
 632                 fattr->cf_mode = S_IFLNK;
 633                 fattr->cf_dtype = DT_LNK;
 634         } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
 635                 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
 636                 fattr->cf_dtype = DT_DIR;
 637                 /*
 638                  * Server can return wrong NumberOfLinks value for directories
 639                  * when Unix extensions are disabled - fake it.
 640                  */
 641                 if (!tcon->unix_ext)
 642                         fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
 643         } else {
 644                 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
 645                 fattr->cf_dtype = DT_REG;
 646 
 647                 /* clear write bits if ATTR_READONLY is set */
 648                 if (fattr->cf_cifsattrs & ATTR_READONLY)
 649                         fattr->cf_mode &= ~(S_IWUGO);
 650 
 651                 /*
 652                  * Don't accept zero nlink from non-unix servers unless
 653                  * delete is pending.  Instead mark it as unknown.
 654                  */
 655                 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
 656                     !info->DeletePending) {
 657                         cifs_dbg(1, "bogus file nlink value %u\n",
 658                                 fattr->cf_nlink);
 659                         fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
 660                 }
 661         }
 662 
 663         fattr->cf_uid = cifs_sb->mnt_uid;
 664         fattr->cf_gid = cifs_sb->mnt_gid;
 665 }
 666 
 667 static int
 668 cifs_get_file_info(struct file *filp)
 669 {
 670         int rc;
 671         unsigned int xid;
 672         FILE_ALL_INFO find_data;
 673         struct cifs_fattr fattr;
 674         struct inode *inode = file_inode(filp);
 675         struct cifsFileInfo *cfile = filp->private_data;
 676         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 677         struct TCP_Server_Info *server = tcon->ses->server;
 678 
 679         if (!server->ops->query_file_info)
 680                 return -ENOSYS;
 681 
 682         xid = get_xid();
 683         rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
 684         switch (rc) {
 685         case 0:
 686                 cifs_all_info_to_fattr(&fattr, &find_data, inode->i_sb, false,
 687                                        false);
 688                 break;
 689         case -EREMOTE:
 690                 cifs_create_dfs_fattr(&fattr, inode->i_sb);
 691                 rc = 0;
 692                 break;
 693         case -EOPNOTSUPP:
 694         case -EINVAL:
 695                 /*
 696                  * FIXME: legacy server -- fall back to path-based call?
 697                  * for now, just skip revalidating and mark inode for
 698                  * immediate reval.
 699                  */
 700                 rc = 0;
 701                 CIFS_I(inode)->time = 0;
 702         default:
 703                 goto cgfi_exit;
 704         }
 705 
 706         /*
 707          * don't bother with SFU junk here -- just mark inode as needing
 708          * revalidation.
 709          */
 710         fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
 711         fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
 712         cifs_fattr_to_inode(inode, &fattr);
 713 cgfi_exit:
 714         free_xid(xid);
 715         return rc;
 716 }
 717 
 718 /* Simple function to return a 64 bit hash of string.  Rarely called */
 719 static __u64 simple_hashstr(const char *str)
 720 {
 721         const __u64 hash_mult =  1125899906842597ULL; /* a big enough prime */
 722         __u64 hash = 0;
 723 
 724         while (*str)
 725                 hash = (hash + (__u64) *str++) * hash_mult;
 726 
 727         return hash;
 728 }
 729 
 730 int
 731 cifs_get_inode_info(struct inode **inode, const char *full_path,
 732                     FILE_ALL_INFO *data, struct super_block *sb, int xid,
 733                     const struct cifs_fid *fid)
 734 {
 735         __u16 srchflgs;
 736         int rc = 0, tmprc = ENOSYS;
 737         struct cifs_tcon *tcon;
 738         struct TCP_Server_Info *server;
 739         struct tcon_link *tlink;
 740         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 741         char *buf = NULL;
 742         bool adjust_tz = false;
 743         struct cifs_fattr fattr;
 744         struct cifs_search_info *srchinf = NULL;
 745         bool symlink = false;
 746 
 747         tlink = cifs_sb_tlink(cifs_sb);
 748         if (IS_ERR(tlink))
 749                 return PTR_ERR(tlink);
 750         tcon = tlink_tcon(tlink);
 751         server = tcon->ses->server;
 752 
 753         cifs_dbg(FYI, "Getting info on %s\n", full_path);
 754 
 755         if ((data == NULL) && (*inode != NULL)) {
 756                 if (CIFS_CACHE_READ(CIFS_I(*inode)) &&
 757                     CIFS_I(*inode)->time != 0) {
 758                         cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
 759                         goto cgii_exit;
 760                 }
 761         }
 762 
 763         /* if inode info is not passed, get it from server */
 764         if (data == NULL) {
 765                 if (!server->ops->query_path_info) {
 766                         rc = -ENOSYS;
 767                         goto cgii_exit;
 768                 }
 769                 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 770                 if (buf == NULL) {
 771                         rc = -ENOMEM;
 772                         goto cgii_exit;
 773                 }
 774                 data = (FILE_ALL_INFO *)buf;
 775                 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
 776                                                   data, &adjust_tz, &symlink);
 777         }
 778 
 779         if (!rc) {
 780                 cifs_all_info_to_fattr(&fattr, data, sb, adjust_tz,
 781                                        symlink);
 782         } else if (rc == -EREMOTE) {
 783                 cifs_create_dfs_fattr(&fattr, sb);
 784                 rc = 0;
 785         } else if ((rc == -EACCES) && backup_cred(cifs_sb) &&
 786                    (strcmp(server->vals->version_string, SMB1_VERSION_STRING)
 787                       == 0)) {
 788                 /*
 789                  * For SMB2 and later the backup intent flag is already
 790                  * sent if needed on open and there is no path based
 791                  * FindFirst operation to use to retry with
 792                  */
 793 
 794                 srchinf = kzalloc(sizeof(struct cifs_search_info),
 795                                         GFP_KERNEL);
 796                 if (srchinf == NULL) {
 797                         rc = -ENOMEM;
 798                         goto cgii_exit;
 799                 }
 800 
 801                 srchinf->endOfSearch = false;
 802                 if (tcon->unix_ext)
 803                         srchinf->info_level = SMB_FIND_FILE_UNIX;
 804                 else if ((tcon->ses->capabilities &
 805                          tcon->ses->server->vals->cap_nt_find) == 0)
 806                         srchinf->info_level = SMB_FIND_FILE_INFO_STANDARD;
 807                 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 808                         srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
 809                 else /* no srvino useful for fallback to some netapp */
 810                         srchinf->info_level = SMB_FIND_FILE_DIRECTORY_INFO;
 811 
 812                 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
 813                                 CIFS_SEARCH_CLOSE_AT_END |
 814                                 CIFS_SEARCH_BACKUP_SEARCH;
 815 
 816                 rc = CIFSFindFirst(xid, tcon, full_path,
 817                         cifs_sb, NULL, srchflgs, srchinf, false);
 818                 if (!rc) {
 819                         data = (FILE_ALL_INFO *)srchinf->srch_entries_start;
 820 
 821                         cifs_dir_info_to_fattr(&fattr,
 822                         (FILE_DIRECTORY_INFO *)data, cifs_sb);
 823                         fattr.cf_uniqueid = le64_to_cpu(
 824                         ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
 825 
 826                         cifs_buf_release(srchinf->ntwrk_buf_start);
 827                 }
 828                 kfree(srchinf);
 829                 if (rc)
 830                         goto cgii_exit;
 831         } else
 832                 goto cgii_exit;
 833 
 834         /*
 835          * If an inode wasn't passed in, then get the inode number
 836          *
 837          * Is an i_ino of zero legal? Can we use that to check if the server
 838          * supports returning inode numbers?  Are there other sanity checks we
 839          * can use to ensure that the server is really filling in that field?
 840          */
 841         if (*inode == NULL) {
 842                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 843                         if (server->ops->get_srv_inum)
 844                                 tmprc = server->ops->get_srv_inum(xid,
 845                                                                   tcon, cifs_sb, full_path,
 846                                                                   &fattr.cf_uniqueid, data);
 847                         if (tmprc) {
 848                                 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
 849                                          tmprc);
 850                                 fattr.cf_uniqueid = iunique(sb, ROOT_I);
 851                                 cifs_autodisable_serverino(cifs_sb);
 852                         } else if ((fattr.cf_uniqueid == 0) &&
 853                                    strlen(full_path) == 0) {
 854                                 /* some servers ret bad root ino ie 0 */
 855                                 cifs_dbg(FYI, "Invalid (0) inodenum\n");
 856                                 fattr.cf_flags |=
 857                                         CIFS_FATTR_FAKE_ROOT_INO;
 858                                 fattr.cf_uniqueid =
 859                                         simple_hashstr(tcon->treeName);
 860                         }
 861                 } else
 862                         fattr.cf_uniqueid = iunique(sb, ROOT_I);
 863         } else {
 864                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 865                     && server->ops->get_srv_inum) {
 866                         /*
 867                          * Pass a NULL tcon to ensure we don't make a round
 868                          * trip to the server. This only works for SMB2+.
 869                          */
 870                         tmprc = server->ops->get_srv_inum(xid,
 871                                 NULL, cifs_sb, full_path,
 872                                 &fattr.cf_uniqueid, data);
 873                         if (tmprc)
 874                                 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
 875                         else if ((fattr.cf_uniqueid == 0) &&
 876                                         strlen(full_path) == 0) {
 877                                 /*
 878                                  * Reuse existing root inode num since
 879                                  * inum zero for root causes ls of . and .. to
 880                                  * not be returned
 881                                  */
 882                                 cifs_dbg(FYI, "Srv ret 0 inode num for root\n");
 883                                 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
 884                         }
 885                 } else
 886                         fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
 887         }
 888 
 889         /* query for SFU type info if supported and needed */
 890         if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
 891             cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
 892                 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
 893                 if (tmprc)
 894                         cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
 895         }
 896 
 897         /* fill in 0777 bits from ACL */
 898         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID) {
 899                 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, true,
 900                                        full_path, fid);
 901                 if (rc) {
 902                         cifs_dbg(FYI, "%s: Get mode from SID failed. rc=%d\n",
 903                                 __func__, rc);
 904                         goto cgii_exit;
 905                 }
 906         } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 907                 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, false,
 908                                        full_path, fid);
 909                 if (rc) {
 910                         cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
 911                                  __func__, rc);
 912                         goto cgii_exit;
 913                 }
 914         }
 915 
 916         /* fill in remaining high mode bits e.g. SUID, VTX */
 917         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 918                 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
 919 
 920         /* check for Minshall+French symlinks */
 921         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 922                 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
 923                                          full_path);
 924                 if (tmprc)
 925                         cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
 926         }
 927 
 928         if (!*inode) {
 929                 *inode = cifs_iget(sb, &fattr);
 930                 if (!*inode)
 931                         rc = -ENOMEM;
 932         } else {
 933                 /* we already have inode, update it */
 934 
 935                 /* if uniqueid is different, return error */
 936                 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 937                     CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
 938                         CIFS_I(*inode)->time = 0; /* force reval */
 939                         rc = -ESTALE;
 940                         goto cgii_exit;
 941                 }
 942 
 943                 /* if filetype is different, return error */
 944                 if (unlikely(((*inode)->i_mode & S_IFMT) !=
 945                     (fattr.cf_mode & S_IFMT))) {
 946                         CIFS_I(*inode)->time = 0; /* force reval */
 947                         rc = -ESTALE;
 948                         goto cgii_exit;
 949                 }
 950 
 951                 cifs_fattr_to_inode(*inode, &fattr);
 952         }
 953 
 954 cgii_exit:
 955         if ((*inode) && ((*inode)->i_ino == 0))
 956                 cifs_dbg(FYI, "inode number of zero returned\n");
 957 
 958         kfree(buf);
 959         cifs_put_tlink(tlink);
 960         return rc;
 961 }
 962 
 963 static const struct inode_operations cifs_ipc_inode_ops = {
 964         .lookup = cifs_lookup,
 965 };
 966 
 967 static int
 968 cifs_find_inode(struct inode *inode, void *opaque)
 969 {
 970         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 971 
 972         /* don't match inode with different uniqueid */
 973         if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
 974                 return 0;
 975 
 976         /* use createtime like an i_generation field */
 977         if (CIFS_I(inode)->createtime != fattr->cf_createtime)
 978                 return 0;
 979 
 980         /* don't match inode of different type */
 981         if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
 982                 return 0;
 983 
 984         /* if it's not a directory or has no dentries, then flag it */
 985         if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
 986                 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
 987 
 988         return 1;
 989 }
 990 
 991 static int
 992 cifs_init_inode(struct inode *inode, void *opaque)
 993 {
 994         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 995 
 996         CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
 997         CIFS_I(inode)->createtime = fattr->cf_createtime;
 998         return 0;
 999 }
1000 
1001 /*
1002  * walk dentry list for an inode and report whether it has aliases that
1003  * are hashed. We use this to determine if a directory inode can actually
1004  * be used.
1005  */
1006 static bool
1007 inode_has_hashed_dentries(struct inode *inode)
1008 {
1009         struct dentry *dentry;
1010 
1011         spin_lock(&inode->i_lock);
1012         hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1013                 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1014                         spin_unlock(&inode->i_lock);
1015                         return true;
1016                 }
1017         }
1018         spin_unlock(&inode->i_lock);
1019         return false;
1020 }
1021 
1022 /* Given fattrs, get a corresponding inode */
1023 struct inode *
1024 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1025 {
1026         unsigned long hash;
1027         struct inode *inode;
1028 
1029 retry_iget5_locked:
1030         cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1031 
1032         /* hash down to 32-bits on 32-bit arch */
1033         hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1034 
1035         inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1036         if (inode) {
1037                 /* was there a potentially problematic inode collision? */
1038                 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1039                         fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1040 
1041                         if (inode_has_hashed_dentries(inode)) {
1042                                 cifs_autodisable_serverino(CIFS_SB(sb));
1043                                 iput(inode);
1044                                 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1045                                 goto retry_iget5_locked;
1046                         }
1047                 }
1048 
1049                 cifs_fattr_to_inode(inode, fattr);
1050                 if (sb->s_flags & SB_NOATIME)
1051                         inode->i_flags |= S_NOATIME | S_NOCMTIME;
1052                 if (inode->i_state & I_NEW) {
1053                         inode->i_ino = hash;
1054 #ifdef CONFIG_CIFS_FSCACHE
1055                         /* initialize per-inode cache cookie pointer */
1056                         CIFS_I(inode)->fscache = NULL;
1057 #endif
1058                         unlock_new_inode(inode);
1059                 }
1060         }
1061 
1062         return inode;
1063 }
1064 
1065 /* gets root inode */
1066 struct inode *cifs_root_iget(struct super_block *sb)
1067 {
1068         unsigned int xid;
1069         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1070         struct inode *inode = NULL;
1071         long rc;
1072         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1073         char *path = NULL;
1074         int len;
1075 
1076         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1077             && cifs_sb->prepath) {
1078                 len = strlen(cifs_sb->prepath);
1079                 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1080                 if (path == NULL)
1081                         return ERR_PTR(-ENOMEM);
1082                 path[0] = '/';
1083                 memcpy(path+1, cifs_sb->prepath, len);
1084         } else {
1085                 path = kstrdup("", GFP_KERNEL);
1086                 if (path == NULL)
1087                         return ERR_PTR(-ENOMEM);
1088         }
1089 
1090         xid = get_xid();
1091         if (tcon->unix_ext) {
1092                 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1093                 /* some servers mistakenly claim POSIX support */
1094                 if (rc != -EOPNOTSUPP)
1095                         goto iget_no_retry;
1096                 cifs_dbg(VFS, "server does not support POSIX extensions");
1097                 tcon->unix_ext = false;
1098         }
1099 
1100         convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1101         rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1102 
1103 iget_no_retry:
1104         if (!inode) {
1105                 inode = ERR_PTR(rc);
1106                 goto out;
1107         }
1108 
1109 #ifdef CONFIG_CIFS_FSCACHE
1110         /* populate tcon->resource_id */
1111         tcon->resource_id = CIFS_I(inode)->uniqueid;
1112 #endif
1113 
1114         if (rc && tcon->pipe) {
1115                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1116                 spin_lock(&inode->i_lock);
1117                 inode->i_mode |= S_IFDIR;
1118                 set_nlink(inode, 2);
1119                 inode->i_op = &cifs_ipc_inode_ops;
1120                 inode->i_fop = &simple_dir_operations;
1121                 inode->i_uid = cifs_sb->mnt_uid;
1122                 inode->i_gid = cifs_sb->mnt_gid;
1123                 spin_unlock(&inode->i_lock);
1124         } else if (rc) {
1125                 iget_failed(inode);
1126                 inode = ERR_PTR(rc);
1127         }
1128 
1129 out:
1130         kfree(path);
1131         free_xid(xid);
1132         return inode;
1133 }
1134 
1135 int
1136 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1137                    char *full_path, __u32 dosattr)
1138 {
1139         bool set_time = false;
1140         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1141         struct TCP_Server_Info *server;
1142         FILE_BASIC_INFO info_buf;
1143 
1144         if (attrs == NULL)
1145                 return -EINVAL;
1146 
1147         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1148         if (!server->ops->set_file_info)
1149                 return -ENOSYS;
1150 
1151         info_buf.Pad = 0;
1152 
1153         if (attrs->ia_valid & ATTR_ATIME) {
1154                 set_time = true;
1155                 info_buf.LastAccessTime =
1156                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1157         } else
1158                 info_buf.LastAccessTime = 0;
1159 
1160         if (attrs->ia_valid & ATTR_MTIME) {
1161                 set_time = true;
1162                 info_buf.LastWriteTime =
1163                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1164         } else
1165                 info_buf.LastWriteTime = 0;
1166 
1167         /*
1168          * Samba throws this field away, but windows may actually use it.
1169          * Do not set ctime unless other time stamps are changed explicitly
1170          * (i.e. by utimes()) since we would then have a mix of client and
1171          * server times.
1172          */
1173         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1174                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1175                 info_buf.ChangeTime =
1176                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1177         } else
1178                 info_buf.ChangeTime = 0;
1179 
1180         info_buf.CreationTime = 0;      /* don't change */
1181         info_buf.Attributes = cpu_to_le32(dosattr);
1182 
1183         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1184 }
1185 
1186 /*
1187  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1188  * and rename it to a random name that hopefully won't conflict with
1189  * anything else.
1190  */
1191 int
1192 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1193                            const unsigned int xid)
1194 {
1195         int oplock = 0;
1196         int rc;
1197         struct cifs_fid fid;
1198         struct cifs_open_parms oparms;
1199         struct inode *inode = d_inode(dentry);
1200         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1201         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1202         struct tcon_link *tlink;
1203         struct cifs_tcon *tcon;
1204         __u32 dosattr, origattr;
1205         FILE_BASIC_INFO *info_buf = NULL;
1206 
1207         tlink = cifs_sb_tlink(cifs_sb);
1208         if (IS_ERR(tlink))
1209                 return PTR_ERR(tlink);
1210         tcon = tlink_tcon(tlink);
1211 
1212         /*
1213          * We cannot rename the file if the server doesn't support
1214          * CAP_INFOLEVEL_PASSTHRU
1215          */
1216         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1217                 rc = -EBUSY;
1218                 goto out;
1219         }
1220 
1221         oparms.tcon = tcon;
1222         oparms.cifs_sb = cifs_sb;
1223         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1224         oparms.create_options = CREATE_NOT_DIR;
1225         oparms.disposition = FILE_OPEN;
1226         oparms.path = full_path;
1227         oparms.fid = &fid;
1228         oparms.reconnect = false;
1229 
1230         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1231         if (rc != 0)
1232                 goto out;
1233 
1234         origattr = cifsInode->cifsAttrs;
1235         if (origattr == 0)
1236                 origattr |= ATTR_NORMAL;
1237 
1238         dosattr = origattr & ~ATTR_READONLY;
1239         if (dosattr == 0)
1240                 dosattr |= ATTR_NORMAL;
1241         dosattr |= ATTR_HIDDEN;
1242 
1243         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1244         if (dosattr != origattr) {
1245                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1246                 if (info_buf == NULL) {
1247                         rc = -ENOMEM;
1248                         goto out_close;
1249                 }
1250                 info_buf->Attributes = cpu_to_le32(dosattr);
1251                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1252                                         current->tgid);
1253                 /* although we would like to mark the file hidden
1254                    if that fails we will still try to rename it */
1255                 if (!rc)
1256                         cifsInode->cifsAttrs = dosattr;
1257                 else
1258                         dosattr = origattr; /* since not able to change them */
1259         }
1260 
1261         /* rename the file */
1262         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1263                                    cifs_sb->local_nls,
1264                                    cifs_remap(cifs_sb));
1265         if (rc != 0) {
1266                 rc = -EBUSY;
1267                 goto undo_setattr;
1268         }
1269 
1270         /* try to set DELETE_ON_CLOSE */
1271         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1272                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1273                                                current->tgid);
1274                 /*
1275                  * some samba versions return -ENOENT when we try to set the
1276                  * file disposition here. Likely a samba bug, but work around
1277                  * it for now. This means that some cifsXXX files may hang
1278                  * around after they shouldn't.
1279                  *
1280                  * BB: remove this hack after more servers have the fix
1281                  */
1282                 if (rc == -ENOENT)
1283                         rc = 0;
1284                 else if (rc != 0) {
1285                         rc = -EBUSY;
1286                         goto undo_rename;
1287                 }
1288                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1289         }
1290 
1291 out_close:
1292         CIFSSMBClose(xid, tcon, fid.netfid);
1293 out:
1294         kfree(info_buf);
1295         cifs_put_tlink(tlink);
1296         return rc;
1297 
1298         /*
1299          * reset everything back to the original state. Don't bother
1300          * dealing with errors here since we can't do anything about
1301          * them anyway.
1302          */
1303 undo_rename:
1304         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1305                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1306 undo_setattr:
1307         if (dosattr != origattr) {
1308                 info_buf->Attributes = cpu_to_le32(origattr);
1309                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1310                                         current->tgid))
1311                         cifsInode->cifsAttrs = origattr;
1312         }
1313 
1314         goto out_close;
1315 }
1316 
1317 /* copied from fs/nfs/dir.c with small changes */
1318 static void
1319 cifs_drop_nlink(struct inode *inode)
1320 {
1321         spin_lock(&inode->i_lock);
1322         if (inode->i_nlink > 0)
1323                 drop_nlink(inode);
1324         spin_unlock(&inode->i_lock);
1325 }
1326 
1327 /*
1328  * If d_inode(dentry) is null (usually meaning the cached dentry
1329  * is a negative dentry) then we would attempt a standard SMB delete, but
1330  * if that fails we can not attempt the fall back mechanisms on EACCES
1331  * but will return the EACCES to the caller. Note that the VFS does not call
1332  * unlink on negative dentries currently.
1333  */
1334 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1335 {
1336         int rc = 0;
1337         unsigned int xid;
1338         char *full_path = NULL;
1339         struct inode *inode = d_inode(dentry);
1340         struct cifsInodeInfo *cifs_inode;
1341         struct super_block *sb = dir->i_sb;
1342         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1343         struct tcon_link *tlink;
1344         struct cifs_tcon *tcon;
1345         struct TCP_Server_Info *server;
1346         struct iattr *attrs = NULL;
1347         __u32 dosattr = 0, origattr = 0;
1348 
1349         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1350 
1351         tlink = cifs_sb_tlink(cifs_sb);
1352         if (IS_ERR(tlink))
1353                 return PTR_ERR(tlink);
1354         tcon = tlink_tcon(tlink);
1355         server = tcon->ses->server;
1356 
1357         xid = get_xid();
1358 
1359         /* Unlink can be called from rename so we can not take the
1360          * sb->s_vfs_rename_mutex here */
1361         full_path = build_path_from_dentry(dentry);
1362         if (full_path == NULL) {
1363                 rc = -ENOMEM;
1364                 goto unlink_out;
1365         }
1366 
1367         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1368                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1369                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1370                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1371                         cifs_remap(cifs_sb));
1372                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1373                 if ((rc == 0) || (rc == -ENOENT))
1374                         goto psx_del_no_retry;
1375         }
1376 
1377 retry_std_delete:
1378         if (!server->ops->unlink) {
1379                 rc = -ENOSYS;
1380                 goto psx_del_no_retry;
1381         }
1382 
1383         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1384 
1385 psx_del_no_retry:
1386         if (!rc) {
1387                 if (inode)
1388                         cifs_drop_nlink(inode);
1389         } else if (rc == -ENOENT) {
1390                 d_drop(dentry);
1391         } else if (rc == -EBUSY) {
1392                 if (server->ops->rename_pending_delete) {
1393                         rc = server->ops->rename_pending_delete(full_path,
1394                                                                 dentry, xid);
1395                         if (rc == 0)
1396                                 cifs_drop_nlink(inode);
1397                 }
1398         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1399                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1400                 if (attrs == NULL) {
1401                         rc = -ENOMEM;
1402                         goto out_reval;
1403                 }
1404 
1405                 /* try to reset dos attributes */
1406                 cifs_inode = CIFS_I(inode);
1407                 origattr = cifs_inode->cifsAttrs;
1408                 if (origattr == 0)
1409                         origattr |= ATTR_NORMAL;
1410                 dosattr = origattr & ~ATTR_READONLY;
1411                 if (dosattr == 0)
1412                         dosattr |= ATTR_NORMAL;
1413                 dosattr |= ATTR_HIDDEN;
1414 
1415                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1416                 if (rc != 0)
1417                         goto out_reval;
1418 
1419                 goto retry_std_delete;
1420         }
1421 
1422         /* undo the setattr if we errored out and it's needed */
1423         if (rc != 0 && dosattr != 0)
1424                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1425 
1426 out_reval:
1427         if (inode) {
1428                 cifs_inode = CIFS_I(inode);
1429                 cifs_inode->time = 0;   /* will force revalidate to get info
1430                                            when needed */
1431                 inode->i_ctime = current_time(inode);
1432         }
1433         dir->i_ctime = dir->i_mtime = current_time(dir);
1434         cifs_inode = CIFS_I(dir);
1435         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1436 unlink_out:
1437         kfree(full_path);
1438         kfree(attrs);
1439         free_xid(xid);
1440         cifs_put_tlink(tlink);
1441         return rc;
1442 }
1443 
1444 static int
1445 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1446                  const char *full_path, struct cifs_sb_info *cifs_sb,
1447                  struct cifs_tcon *tcon, const unsigned int xid)
1448 {
1449         int rc = 0;
1450         struct inode *inode = NULL;
1451 
1452         if (tcon->unix_ext)
1453                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1454                                               xid);
1455         else
1456                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1457                                          xid, NULL);
1458 
1459         if (rc)
1460                 return rc;
1461 
1462         /*
1463          * setting nlink not necessary except in cases where we failed to get it
1464          * from the server or was set bogus. Also, since this is a brand new
1465          * inode, no need to grab the i_lock before setting the i_nlink.
1466          */
1467         if (inode->i_nlink < 2)
1468                 set_nlink(inode, 2);
1469         mode &= ~current_umask();
1470         /* must turn on setgid bit if parent dir has it */
1471         if (parent->i_mode & S_ISGID)
1472                 mode |= S_ISGID;
1473 
1474         if (tcon->unix_ext) {
1475                 struct cifs_unix_set_info_args args = {
1476                         .mode   = mode,
1477                         .ctime  = NO_CHANGE_64,
1478                         .atime  = NO_CHANGE_64,
1479                         .mtime  = NO_CHANGE_64,
1480                         .device = 0,
1481                 };
1482                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1483                         args.uid = current_fsuid();
1484                         if (parent->i_mode & S_ISGID)
1485                                 args.gid = parent->i_gid;
1486                         else
1487                                 args.gid = current_fsgid();
1488                 } else {
1489                         args.uid = INVALID_UID; /* no change */
1490                         args.gid = INVALID_GID; /* no change */
1491                 }
1492                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1493                                        cifs_sb->local_nls,
1494                                        cifs_remap(cifs_sb));
1495         } else {
1496                 struct TCP_Server_Info *server = tcon->ses->server;
1497                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1498                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1499                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1500                                                    tcon, xid);
1501                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1502                         inode->i_mode = (mode | S_IFDIR);
1503 
1504                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1505                         inode->i_uid = current_fsuid();
1506                         if (inode->i_mode & S_ISGID)
1507                                 inode->i_gid = parent->i_gid;
1508                         else
1509                                 inode->i_gid = current_fsgid();
1510                 }
1511         }
1512         d_instantiate(dentry, inode);
1513         return rc;
1514 }
1515 
1516 static int
1517 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1518                  const char *full_path, struct cifs_sb_info *cifs_sb,
1519                  struct cifs_tcon *tcon, const unsigned int xid)
1520 {
1521         int rc = 0;
1522         u32 oplock = 0;
1523         FILE_UNIX_BASIC_INFO *info = NULL;
1524         struct inode *newinode = NULL;
1525         struct cifs_fattr fattr;
1526 
1527         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1528         if (info == NULL) {
1529                 rc = -ENOMEM;
1530                 goto posix_mkdir_out;
1531         }
1532 
1533         mode &= ~current_umask();
1534         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1535                              NULL /* netfid */, info, &oplock, full_path,
1536                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1537         if (rc == -EOPNOTSUPP)
1538                 goto posix_mkdir_out;
1539         else if (rc) {
1540                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1541                 d_drop(dentry);
1542                 goto posix_mkdir_out;
1543         }
1544 
1545         if (info->Type == cpu_to_le32(-1))
1546                 /* no return info, go query for it */
1547                 goto posix_mkdir_get_info;
1548         /*
1549          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1550          * need to set uid/gid.
1551          */
1552 
1553         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1554         cifs_fill_uniqueid(inode->i_sb, &fattr);
1555         newinode = cifs_iget(inode->i_sb, &fattr);
1556         if (!newinode)
1557                 goto posix_mkdir_get_info;
1558 
1559         d_instantiate(dentry, newinode);
1560 
1561 #ifdef CONFIG_CIFS_DEBUG2
1562         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1563                  dentry, dentry, newinode);
1564 
1565         if (newinode->i_nlink != 2)
1566                 cifs_dbg(FYI, "unexpected number of links %d\n",
1567                          newinode->i_nlink);
1568 #endif
1569 
1570 posix_mkdir_out:
1571         kfree(info);
1572         return rc;
1573 posix_mkdir_get_info:
1574         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1575                               xid);
1576         goto posix_mkdir_out;
1577 }
1578 
1579 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1580 {
1581         int rc = 0;
1582         unsigned int xid;
1583         struct cifs_sb_info *cifs_sb;
1584         struct tcon_link *tlink;
1585         struct cifs_tcon *tcon;
1586         struct TCP_Server_Info *server;
1587         char *full_path;
1588 
1589         cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1590                  mode, inode);
1591 
1592         cifs_sb = CIFS_SB(inode->i_sb);
1593         tlink = cifs_sb_tlink(cifs_sb);
1594         if (IS_ERR(tlink))
1595                 return PTR_ERR(tlink);
1596         tcon = tlink_tcon(tlink);
1597 
1598         xid = get_xid();
1599 
1600         full_path = build_path_from_dentry(direntry);
1601         if (full_path == NULL) {
1602                 rc = -ENOMEM;
1603                 goto mkdir_out;
1604         }
1605 
1606         server = tcon->ses->server;
1607 
1608         if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1609                 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1610                                               cifs_sb);
1611                 d_drop(direntry); /* for time being always refresh inode info */
1612                 goto mkdir_out;
1613         }
1614 
1615         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1616                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1617                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1618                                       tcon, xid);
1619                 if (rc != -EOPNOTSUPP)
1620                         goto mkdir_out;
1621         }
1622 
1623         if (!server->ops->mkdir) {
1624                 rc = -ENOSYS;
1625                 goto mkdir_out;
1626         }
1627 
1628         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1629         rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1630         if (rc) {
1631                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1632                 d_drop(direntry);
1633                 goto mkdir_out;
1634         }
1635 
1636         /* TODO: skip this for smb2/smb3 */
1637         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1638                               xid);
1639 mkdir_out:
1640         /*
1641          * Force revalidate to get parent dir info when needed since cached
1642          * attributes are invalid now.
1643          */
1644         CIFS_I(inode)->time = 0;
1645         kfree(full_path);
1646         free_xid(xid);
1647         cifs_put_tlink(tlink);
1648         return rc;
1649 }
1650 
1651 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1652 {
1653         int rc = 0;
1654         unsigned int xid;
1655         struct cifs_sb_info *cifs_sb;
1656         struct tcon_link *tlink;
1657         struct cifs_tcon *tcon;
1658         struct TCP_Server_Info *server;
1659         char *full_path = NULL;
1660         struct cifsInodeInfo *cifsInode;
1661 
1662         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1663 
1664         xid = get_xid();
1665 
1666         full_path = build_path_from_dentry(direntry);
1667         if (full_path == NULL) {
1668                 rc = -ENOMEM;
1669                 goto rmdir_exit;
1670         }
1671 
1672         cifs_sb = CIFS_SB(inode->i_sb);
1673         tlink = cifs_sb_tlink(cifs_sb);
1674         if (IS_ERR(tlink)) {
1675                 rc = PTR_ERR(tlink);
1676                 goto rmdir_exit;
1677         }
1678         tcon = tlink_tcon(tlink);
1679         server = tcon->ses->server;
1680 
1681         if (!server->ops->rmdir) {
1682                 rc = -ENOSYS;
1683                 cifs_put_tlink(tlink);
1684                 goto rmdir_exit;
1685         }
1686 
1687         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1688         cifs_put_tlink(tlink);
1689 
1690         if (!rc) {
1691                 spin_lock(&d_inode(direntry)->i_lock);
1692                 i_size_write(d_inode(direntry), 0);
1693                 clear_nlink(d_inode(direntry));
1694                 spin_unlock(&d_inode(direntry)->i_lock);
1695         }
1696 
1697         cifsInode = CIFS_I(d_inode(direntry));
1698         /* force revalidate to go get info when needed */
1699         cifsInode->time = 0;
1700 
1701         cifsInode = CIFS_I(inode);
1702         /*
1703          * Force revalidate to get parent dir info when needed since cached
1704          * attributes are invalid now.
1705          */
1706         cifsInode->time = 0;
1707 
1708         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1709                 current_time(inode);
1710 
1711 rmdir_exit:
1712         kfree(full_path);
1713         free_xid(xid);
1714         return rc;
1715 }
1716 
1717 static int
1718 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1719                const char *from_path, struct dentry *to_dentry,
1720                const char *to_path)
1721 {
1722         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1723         struct tcon_link *tlink;
1724         struct cifs_tcon *tcon;
1725         struct TCP_Server_Info *server;
1726         struct cifs_fid fid;
1727         struct cifs_open_parms oparms;
1728         int oplock, rc;
1729 
1730         tlink = cifs_sb_tlink(cifs_sb);
1731         if (IS_ERR(tlink))
1732                 return PTR_ERR(tlink);
1733         tcon = tlink_tcon(tlink);
1734         server = tcon->ses->server;
1735 
1736         if (!server->ops->rename)
1737                 return -ENOSYS;
1738 
1739         /* try path-based rename first */
1740         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1741 
1742         /*
1743          * Don't bother with rename by filehandle unless file is busy and
1744          * source. Note that cross directory moves do not work with
1745          * rename by filehandle to various Windows servers.
1746          */
1747         if (rc == 0 || rc != -EBUSY)
1748                 goto do_rename_exit;
1749 
1750         /* Don't fall back to using SMB on SMB 2+ mount */
1751         if (server->vals->protocol_id != 0)
1752                 goto do_rename_exit;
1753 
1754         /* open-file renames don't work across directories */
1755         if (to_dentry->d_parent != from_dentry->d_parent)
1756                 goto do_rename_exit;
1757 
1758         oparms.tcon = tcon;
1759         oparms.cifs_sb = cifs_sb;
1760         /* open the file to be renamed -- we need DELETE perms */
1761         oparms.desired_access = DELETE;
1762         oparms.create_options = CREATE_NOT_DIR;
1763         oparms.disposition = FILE_OPEN;
1764         oparms.path = from_path;
1765         oparms.fid = &fid;
1766         oparms.reconnect = false;
1767 
1768         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1769         if (rc == 0) {
1770                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1771                                 (const char *) to_dentry->d_name.name,
1772                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1773                 CIFSSMBClose(xid, tcon, fid.netfid);
1774         }
1775 do_rename_exit:
1776         cifs_put_tlink(tlink);
1777         return rc;
1778 }
1779 
1780 int
1781 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1782              struct inode *target_dir, struct dentry *target_dentry,
1783              unsigned int flags)
1784 {
1785         char *from_name = NULL;
1786         char *to_name = NULL;
1787         struct cifs_sb_info *cifs_sb;
1788         struct tcon_link *tlink;
1789         struct cifs_tcon *tcon;
1790         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1791         FILE_UNIX_BASIC_INFO *info_buf_target;
1792         unsigned int xid;
1793         int rc, tmprc;
1794 
1795         if (flags & ~RENAME_NOREPLACE)
1796                 return -EINVAL;
1797 
1798         cifs_sb = CIFS_SB(source_dir->i_sb);
1799         tlink = cifs_sb_tlink(cifs_sb);
1800         if (IS_ERR(tlink))
1801                 return PTR_ERR(tlink);
1802         tcon = tlink_tcon(tlink);
1803 
1804         xid = get_xid();
1805 
1806         /*
1807          * we already have the rename sem so we do not need to
1808          * grab it again here to protect the path integrity
1809          */
1810         from_name = build_path_from_dentry(source_dentry);
1811         if (from_name == NULL) {
1812                 rc = -ENOMEM;
1813                 goto cifs_rename_exit;
1814         }
1815 
1816         to_name = build_path_from_dentry(target_dentry);
1817         if (to_name == NULL) {
1818                 rc = -ENOMEM;
1819                 goto cifs_rename_exit;
1820         }
1821 
1822         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1823                             to_name);
1824 
1825         /*
1826          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1827          */
1828         if (flags & RENAME_NOREPLACE)
1829                 goto cifs_rename_exit;
1830 
1831         if (rc == -EEXIST && tcon->unix_ext) {
1832                 /*
1833                  * Are src and dst hardlinks of same inode? We can only tell
1834                  * with unix extensions enabled.
1835                  */
1836                 info_buf_source =
1837                         kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1838                                         GFP_KERNEL);
1839                 if (info_buf_source == NULL) {
1840                         rc = -ENOMEM;
1841                         goto cifs_rename_exit;
1842                 }
1843 
1844                 info_buf_target = info_buf_source + 1;
1845                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1846                                              info_buf_source,
1847                                              cifs_sb->local_nls,
1848                                              cifs_remap(cifs_sb));
1849                 if (tmprc != 0)
1850                         goto unlink_target;
1851 
1852                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1853                                              info_buf_target,
1854                                              cifs_sb->local_nls,
1855                                              cifs_remap(cifs_sb));
1856 
1857                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1858                                    info_buf_target->UniqueId)) {
1859                         /* same file, POSIX says that this is a noop */
1860                         rc = 0;
1861                         goto cifs_rename_exit;
1862                 }
1863         }
1864         /*
1865          * else ... BB we could add the same check for Windows by
1866          * checking the UniqueId via FILE_INTERNAL_INFO
1867          */
1868 
1869 unlink_target:
1870         /* Try unlinking the target dentry if it's not negative */
1871         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1872                 if (d_is_dir(target_dentry))
1873                         tmprc = cifs_rmdir(target_dir, target_dentry);
1874                 else
1875                         tmprc = cifs_unlink(target_dir, target_dentry);
1876                 if (tmprc)
1877                         goto cifs_rename_exit;
1878                 rc = cifs_do_rename(xid, source_dentry, from_name,
1879                                     target_dentry, to_name);
1880         }
1881 
1882         /* force revalidate to go get info when needed */
1883         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1884 
1885         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1886                 target_dir->i_mtime = current_time(source_dir);
1887 
1888 cifs_rename_exit:
1889         kfree(info_buf_source);
1890         kfree(from_name);
1891         kfree(to_name);
1892         free_xid(xid);
1893         cifs_put_tlink(tlink);
1894         return rc;
1895 }
1896 
1897 static bool
1898 cifs_inode_needs_reval(struct inode *inode)
1899 {
1900         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1901         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1902 
1903         if (cifs_i->time == 0)
1904                 return true;
1905 
1906         if (CIFS_CACHE_READ(cifs_i))
1907                 return false;
1908 
1909         if (!lookupCacheEnabled)
1910                 return true;
1911 
1912         if (!cifs_sb->actimeo)
1913                 return true;
1914 
1915         if (!time_in_range(jiffies, cifs_i->time,
1916                                 cifs_i->time + cifs_sb->actimeo))
1917                 return true;
1918 
1919         /* hardlinked files w/ noserverino get "special" treatment */
1920         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1921             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1922                 return true;
1923 
1924         return false;
1925 }
1926 
1927 /*
1928  * Zap the cache. Called when invalid_mapping flag is set.
1929  */
1930 int
1931 cifs_invalidate_mapping(struct inode *inode)
1932 {
1933         int rc = 0;
1934 
1935         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1936                 rc = invalidate_inode_pages2(inode->i_mapping);
1937                 if (rc)
1938                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1939                                  __func__, inode);
1940         }
1941 
1942         cifs_fscache_reset_inode_cookie(inode);
1943         return rc;
1944 }
1945 
1946 /**
1947  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1948  * @word: long word containing the bit lock
1949  */
1950 static int
1951 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1952 {
1953         freezable_schedule_unsafe();
1954         if (signal_pending_state(mode, current))
1955                 return -ERESTARTSYS;
1956         return 0;
1957 }
1958 
1959 int
1960 cifs_revalidate_mapping(struct inode *inode)
1961 {
1962         int rc;
1963         unsigned long *flags = &CIFS_I(inode)->flags;
1964 
1965         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1966                                      TASK_KILLABLE);
1967         if (rc)
1968                 return rc;
1969 
1970         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1971                 rc = cifs_invalidate_mapping(inode);
1972                 if (rc)
1973                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1974         }
1975 
1976         clear_bit_unlock(CIFS_INO_LOCK, flags);
1977         smp_mb__after_atomic();
1978         wake_up_bit(flags, CIFS_INO_LOCK);
1979 
1980         return rc;
1981 }
1982 
1983 int
1984 cifs_zap_mapping(struct inode *inode)
1985 {
1986         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1987         return cifs_revalidate_mapping(inode);
1988 }
1989 
1990 int cifs_revalidate_file_attr(struct file *filp)
1991 {
1992         int rc = 0;
1993         struct inode *inode = file_inode(filp);
1994         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1995 
1996         if (!cifs_inode_needs_reval(inode))
1997                 return rc;
1998 
1999         if (tlink_tcon(cfile->tlink)->unix_ext)
2000                 rc = cifs_get_file_info_unix(filp);
2001         else
2002                 rc = cifs_get_file_info(filp);
2003 
2004         return rc;
2005 }
2006 
2007 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2008 {
2009         unsigned int xid;
2010         int rc = 0;
2011         struct inode *inode = d_inode(dentry);
2012         struct super_block *sb = dentry->d_sb;
2013         char *full_path = NULL;
2014         int count = 0;
2015 
2016         if (inode == NULL)
2017                 return -ENOENT;
2018 
2019         if (!cifs_inode_needs_reval(inode))
2020                 return rc;
2021 
2022         xid = get_xid();
2023 
2024         /* can not safely grab the rename sem here if rename calls revalidate
2025            since that would deadlock */
2026         full_path = build_path_from_dentry(dentry);
2027         if (full_path == NULL) {
2028                 rc = -ENOMEM;
2029                 goto out;
2030         }
2031 
2032         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2033                  full_path, inode, inode->i_count.counter,
2034                  dentry, cifs_get_time(dentry), jiffies);
2035 
2036 again:
2037         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2038                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2039         else
2040                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2041                                          xid, NULL);
2042         if (rc == -EAGAIN && count++ < 10)
2043                 goto again;
2044 out:
2045         kfree(full_path);
2046         free_xid(xid);
2047 
2048         return rc;
2049 }
2050 
2051 int cifs_revalidate_file(struct file *filp)
2052 {
2053         int rc;
2054         struct inode *inode = file_inode(filp);
2055 
2056         rc = cifs_revalidate_file_attr(filp);
2057         if (rc)
2058                 return rc;
2059 
2060         return cifs_revalidate_mapping(inode);
2061 }
2062 
2063 /* revalidate a dentry's inode attributes */
2064 int cifs_revalidate_dentry(struct dentry *dentry)
2065 {
2066         int rc;
2067         struct inode *inode = d_inode(dentry);
2068 
2069         rc = cifs_revalidate_dentry_attr(dentry);
2070         if (rc)
2071                 return rc;
2072 
2073         return cifs_revalidate_mapping(inode);
2074 }
2075 
2076 int cifs_getattr(const struct path *path, struct kstat *stat,
2077                  u32 request_mask, unsigned int flags)
2078 {
2079         struct dentry *dentry = path->dentry;
2080         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2081         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2082         struct inode *inode = d_inode(dentry);
2083         int rc;
2084 
2085         /*
2086          * We need to be sure that all dirty pages are written and the server
2087          * has actual ctime, mtime and file length.
2088          */
2089         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2090             inode->i_mapping->nrpages != 0) {
2091                 rc = filemap_fdatawait(inode->i_mapping);
2092                 if (rc) {
2093                         mapping_set_error(inode->i_mapping, rc);
2094                         return rc;
2095                 }
2096         }
2097 
2098         rc = cifs_revalidate_dentry_attr(dentry);
2099         if (rc)
2100                 return rc;
2101 
2102         generic_fillattr(inode, stat);
2103         stat->blksize = cifs_sb->bsize;
2104         stat->ino = CIFS_I(inode)->uniqueid;
2105 
2106         /* old CIFS Unix Extensions doesn't return create time */
2107         if (CIFS_I(inode)->createtime) {
2108                 stat->result_mask |= STATX_BTIME;
2109                 stat->btime =
2110                       cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2111         }
2112 
2113         stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2114         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2115                 stat->attributes |= STATX_ATTR_COMPRESSED;
2116         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2117                 stat->attributes |= STATX_ATTR_ENCRYPTED;
2118 
2119         /*
2120          * If on a multiuser mount without unix extensions or cifsacl being
2121          * enabled, and the admin hasn't overridden them, set the ownership
2122          * to the fsuid/fsgid of the current process.
2123          */
2124         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2125             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2126             !tcon->unix_ext) {
2127                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2128                         stat->uid = current_fsuid();
2129                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2130                         stat->gid = current_fsgid();
2131         }
2132         return rc;
2133 }
2134 
2135 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2136                 u64 len)
2137 {
2138         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2139         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2140         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2141         struct TCP_Server_Info *server = tcon->ses->server;
2142         struct cifsFileInfo *cfile;
2143         int rc;
2144 
2145         /*
2146          * We need to be sure that all dirty pages are written as they
2147          * might fill holes on the server.
2148          */
2149         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2150             inode->i_mapping->nrpages != 0) {
2151                 rc = filemap_fdatawait(inode->i_mapping);
2152                 if (rc) {
2153                         mapping_set_error(inode->i_mapping, rc);
2154                         return rc;
2155                 }
2156         }
2157 
2158         cfile = find_readable_file(cifs_i, false);
2159         if (cfile == NULL)
2160                 return -EINVAL;
2161 
2162         if (server->ops->fiemap) {
2163                 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2164                 cifsFileInfo_put(cfile);
2165                 return rc;
2166         }
2167 
2168         cifsFileInfo_put(cfile);
2169         return -ENOTSUPP;
2170 }
2171 
2172 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2173 {
2174         pgoff_t index = from >> PAGE_SHIFT;
2175         unsigned offset = from & (PAGE_SIZE - 1);
2176         struct page *page;
2177         int rc = 0;
2178 
2179         page = grab_cache_page(mapping, index);
2180         if (!page)
2181                 return -ENOMEM;
2182 
2183         zero_user_segment(page, offset, PAGE_SIZE);
2184         unlock_page(page);
2185         put_page(page);
2186         return rc;
2187 }
2188 
2189 static void cifs_setsize(struct inode *inode, loff_t offset)
2190 {
2191         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2192 
2193         spin_lock(&inode->i_lock);
2194         i_size_write(inode, offset);
2195         spin_unlock(&inode->i_lock);
2196 
2197         /* Cached inode must be refreshed on truncate */
2198         cifs_i->time = 0;
2199         truncate_pagecache(inode, offset);
2200 }
2201 
2202 static int
2203 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2204                    unsigned int xid, char *full_path)
2205 {
2206         int rc;
2207         struct cifsFileInfo *open_file;
2208         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2209         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2210         struct tcon_link *tlink = NULL;
2211         struct cifs_tcon *tcon = NULL;
2212         struct TCP_Server_Info *server;
2213 
2214         /*
2215          * To avoid spurious oplock breaks from server, in the case of
2216          * inodes that we already have open, avoid doing path based
2217          * setting of file size if we can do it by handle.
2218          * This keeps our caching token (oplock) and avoids timeouts
2219          * when the local oplock break takes longer to flush
2220          * writebehind data than the SMB timeout for the SetPathInfo
2221          * request would allow
2222          */
2223         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2224         if (open_file) {
2225                 tcon = tlink_tcon(open_file->tlink);
2226                 server = tcon->ses->server;
2227                 if (server->ops->set_file_size)
2228                         rc = server->ops->set_file_size(xid, tcon, open_file,
2229                                                         attrs->ia_size, false);
2230                 else
2231                         rc = -ENOSYS;
2232                 cifsFileInfo_put(open_file);
2233                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2234         } else
2235                 rc = -EINVAL;
2236 
2237         if (!rc)
2238                 goto set_size_out;
2239 
2240         if (tcon == NULL) {
2241                 tlink = cifs_sb_tlink(cifs_sb);
2242                 if (IS_ERR(tlink))
2243                         return PTR_ERR(tlink);
2244                 tcon = tlink_tcon(tlink);
2245                 server = tcon->ses->server;
2246         }
2247 
2248         /*
2249          * Set file size by pathname rather than by handle either because no
2250          * valid, writeable file handle for it was found or because there was
2251          * an error setting it by handle.
2252          */
2253         if (server->ops->set_path_size)
2254                 rc = server->ops->set_path_size(xid, tcon, full_path,
2255                                                 attrs->ia_size, cifs_sb, false);
2256         else
2257                 rc = -ENOSYS;
2258         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2259 
2260         if (tlink)
2261                 cifs_put_tlink(tlink);
2262 
2263 set_size_out:
2264         if (rc == 0) {
2265                 cifsInode->server_eof = attrs->ia_size;
2266                 cifs_setsize(inode, attrs->ia_size);
2267                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2268         }
2269 
2270         return rc;
2271 }
2272 
2273 static int
2274 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2275 {
2276         int rc;
2277         unsigned int xid;
2278         char *full_path = NULL;
2279         struct inode *inode = d_inode(direntry);
2280         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2281         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2282         struct tcon_link *tlink;
2283         struct cifs_tcon *pTcon;
2284         struct cifs_unix_set_info_args *args = NULL;
2285         struct cifsFileInfo *open_file;
2286 
2287         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2288                  direntry, attrs->ia_valid);
2289 
2290         xid = get_xid();
2291 
2292         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2293                 attrs->ia_valid |= ATTR_FORCE;
2294 
2295         rc = setattr_prepare(direntry, attrs);
2296         if (rc < 0)
2297                 goto out;
2298 
2299         full_path = build_path_from_dentry(direntry);
2300         if (full_path == NULL) {
2301                 rc = -ENOMEM;
2302                 goto out;
2303         }
2304 
2305         /*
2306          * Attempt to flush data before changing attributes. We need to do
2307          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2308          * ownership or mode then we may also need to do this. Here, we take
2309          * the safe way out and just do the flush on all setattr requests. If
2310          * the flush returns error, store it to report later and continue.
2311          *
2312          * BB: This should be smarter. Why bother flushing pages that
2313          * will be truncated anyway? Also, should we error out here if
2314          * the flush returns error?
2315          */
2316         rc = filemap_write_and_wait(inode->i_mapping);
2317         if (is_interrupt_error(rc)) {
2318                 rc = -ERESTARTSYS;
2319                 goto out;
2320         }
2321 
2322         mapping_set_error(inode->i_mapping, rc);
2323         rc = 0;
2324 
2325         if (attrs->ia_valid & ATTR_SIZE) {
2326                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2327                 if (rc != 0)
2328                         goto out;
2329         }
2330 
2331         /* skip mode change if it's just for clearing setuid/setgid */
2332         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2333                 attrs->ia_valid &= ~ATTR_MODE;
2334 
2335         args = kmalloc(sizeof(*args), GFP_KERNEL);
2336         if (args == NULL) {
2337                 rc = -ENOMEM;
2338                 goto out;
2339         }
2340 
2341         /* set up the struct */
2342         if (attrs->ia_valid & ATTR_MODE)
2343                 args->mode = attrs->ia_mode;
2344         else
2345                 args->mode = NO_CHANGE_64;
2346 
2347         if (attrs->ia_valid & ATTR_UID)
2348                 args->uid = attrs->ia_uid;
2349         else
2350                 args->uid = INVALID_UID; /* no change */
2351 
2352         if (attrs->ia_valid & ATTR_GID)
2353                 args->gid = attrs->ia_gid;
2354         else
2355                 args->gid = INVALID_GID; /* no change */
2356 
2357         if (attrs->ia_valid & ATTR_ATIME)
2358                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2359         else
2360                 args->atime = NO_CHANGE_64;
2361 
2362         if (attrs->ia_valid & ATTR_MTIME)
2363                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2364         else
2365                 args->mtime = NO_CHANGE_64;
2366 
2367         if (attrs->ia_valid & ATTR_CTIME)
2368                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2369         else
2370                 args->ctime = NO_CHANGE_64;
2371 
2372         args->device = 0;
2373         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2374         if (open_file) {
2375                 u16 nfid = open_file->fid.netfid;
2376                 u32 npid = open_file->pid;
2377                 pTcon = tlink_tcon(open_file->tlink);
2378                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2379                 cifsFileInfo_put(open_file);
2380         } else {
2381                 tlink = cifs_sb_tlink(cifs_sb);
2382                 if (IS_ERR(tlink)) {
2383                         rc = PTR_ERR(tlink);
2384                         goto out;
2385                 }
2386                 pTcon = tlink_tcon(tlink);
2387                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2388                                     cifs_sb->local_nls,
2389                                     cifs_remap(cifs_sb));
2390                 cifs_put_tlink(tlink);
2391         }
2392 
2393         if (rc)
2394                 goto out;
2395 
2396         if ((attrs->ia_valid & ATTR_SIZE) &&
2397             attrs->ia_size != i_size_read(inode))
2398                 truncate_setsize(inode, attrs->ia_size);
2399 
2400         setattr_copy(inode, attrs);
2401         mark_inode_dirty(inode);
2402 
2403         /* force revalidate when any of these times are set since some
2404            of the fs types (eg ext3, fat) do not have fine enough
2405            time granularity to match protocol, and we do not have a
2406            a way (yet) to query the server fs's time granularity (and
2407            whether it rounds times down).
2408         */
2409         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2410                 cifsInode->time = 0;
2411 out:
2412         kfree(args);
2413         kfree(full_path);
2414         free_xid(xid);
2415         return rc;
2416 }
2417 
2418 static int
2419 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2420 {
2421         unsigned int xid;
2422         kuid_t uid = INVALID_UID;
2423         kgid_t gid = INVALID_GID;
2424         struct inode *inode = d_inode(direntry);
2425         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2426         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2427         struct cifsFileInfo *wfile;
2428         struct cifs_tcon *tcon;
2429         char *full_path = NULL;
2430         int rc = -EACCES;
2431         __u32 dosattr = 0;
2432         __u64 mode = NO_CHANGE_64;
2433 
2434         xid = get_xid();
2435 
2436         cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2437                  direntry, attrs->ia_valid);
2438 
2439         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2440                 attrs->ia_valid |= ATTR_FORCE;
2441 
2442         rc = setattr_prepare(direntry, attrs);
2443         if (rc < 0) {
2444                 free_xid(xid);
2445                 return rc;
2446         }
2447 
2448         full_path = build_path_from_dentry(direntry);
2449         if (full_path == NULL) {
2450                 rc = -ENOMEM;
2451                 free_xid(xid);
2452                 return rc;
2453         }
2454 
2455         /*
2456          * Attempt to flush data before changing attributes. We need to do
2457          * this for ATTR_SIZE and ATTR_MTIME.  If the flush of the data
2458          * returns error, store it to report later and continue.
2459          *
2460          * BB: This should be smarter. Why bother flushing pages that
2461          * will be truncated anyway? Also, should we error out here if
2462          * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2463          */
2464         if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2465                 rc = filemap_write_and_wait(inode->i_mapping);
2466                 if (is_interrupt_error(rc)) {
2467                         rc = -ERESTARTSYS;
2468                         goto cifs_setattr_exit;
2469                 }
2470                 mapping_set_error(inode->i_mapping, rc);
2471         }
2472 
2473         rc = 0;
2474 
2475         if ((attrs->ia_valid & ATTR_MTIME) &&
2476             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2477                 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2478                 if (!rc) {
2479                         tcon = tlink_tcon(wfile->tlink);
2480                         rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2481                         cifsFileInfo_put(wfile);
2482                         if (rc)
2483                                 goto cifs_setattr_exit;
2484                 } else if (rc != -EBADF)
2485                         goto cifs_setattr_exit;
2486                 else
2487                         rc = 0;
2488         }
2489 
2490         if (attrs->ia_valid & ATTR_SIZE) {
2491                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2492                 if (rc != 0)
2493                         goto cifs_setattr_exit;
2494         }
2495 
2496         if (attrs->ia_valid & ATTR_UID)
2497                 uid = attrs->ia_uid;
2498 
2499         if (attrs->ia_valid & ATTR_GID)
2500                 gid = attrs->ia_gid;
2501 
2502         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2503             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2504                 if (uid_valid(uid) || gid_valid(gid)) {
2505                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2506                                                         uid, gid);
2507                         if (rc) {
2508                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2509                                          __func__, rc);
2510                                 goto cifs_setattr_exit;
2511                         }
2512                 }
2513         } else
2514         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2515                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2516 
2517         /* skip mode change if it's just for clearing setuid/setgid */
2518         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2519                 attrs->ia_valid &= ~ATTR_MODE;
2520 
2521         if (attrs->ia_valid & ATTR_MODE) {
2522                 mode = attrs->ia_mode;
2523                 rc = 0;
2524                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2525                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2526                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2527                                                 INVALID_UID, INVALID_GID);
2528                         if (rc) {
2529                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2530                                          __func__, rc);
2531                                 goto cifs_setattr_exit;
2532                         }
2533                 } else
2534                 if (((mode & S_IWUGO) == 0) &&
2535                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2536 
2537                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2538 
2539                         /* fix up mode if we're not using dynperm */
2540                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2541                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2542                 } else if ((mode & S_IWUGO) &&
2543                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2544 
2545                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2546                         /* Attributes of 0 are ignored */
2547                         if (dosattr == 0)
2548                                 dosattr |= ATTR_NORMAL;
2549 
2550                         /* reset local inode permissions to normal */
2551                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2552                                 attrs->ia_mode &= ~(S_IALLUGO);
2553                                 if (S_ISDIR(inode->i_mode))
2554                                         attrs->ia_mode |=
2555                                                 cifs_sb->mnt_dir_mode;
2556                                 else
2557                                         attrs->ia_mode |=
2558                                                 cifs_sb->mnt_file_mode;
2559                         }
2560                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2561                         /* ignore mode change - ATTR_READONLY hasn't changed */
2562                         attrs->ia_valid &= ~ATTR_MODE;
2563                 }
2564         }
2565 
2566         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2567             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2568                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2569                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2570 
2571                 /* Even if error on time set, no sense failing the call if
2572                 the server would set the time to a reasonable value anyway,
2573                 and this check ensures that we are not being called from
2574                 sys_utimes in which case we ought to fail the call back to
2575                 the user when the server rejects the call */
2576                 if ((rc) && (attrs->ia_valid &
2577                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2578                         rc = 0;
2579         }
2580 
2581         /* do not need local check to inode_check_ok since the server does
2582            that */
2583         if (rc)
2584                 goto cifs_setattr_exit;
2585 
2586         if ((attrs->ia_valid & ATTR_SIZE) &&
2587             attrs->ia_size != i_size_read(inode))
2588                 truncate_setsize(inode, attrs->ia_size);
2589 
2590         setattr_copy(inode, attrs);
2591         mark_inode_dirty(inode);
2592 
2593 cifs_setattr_exit:
2594         kfree(full_path);
2595         free_xid(xid);
2596         return rc;
2597 }
2598 
2599 int
2600 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2601 {
2602         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2603         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2604 
2605         if (pTcon->unix_ext)
2606                 return cifs_setattr_unix(direntry, attrs);
2607 
2608         return cifs_setattr_nounix(direntry, attrs);
2609 
2610         /* BB: add cifs_setattr_legacy for really old servers */
2611 }
2612 
2613 #if 0
2614 void cifs_delete_inode(struct inode *inode)
2615 {
2616         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2617         /* may have to add back in if and when safe distributed caching of
2618            directories added e.g. via FindNotify */
2619 }
2620 #endif

/* [<][>][^][v][top][bottom][index][help] */