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