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