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