smb/client/inode.c

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