fs/cifs/inode.c

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