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