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