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