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