fs/cifs/inode.c

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