fs/cifs/inode.c

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