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