fs/cifs/inode.c

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