fs/cifs/inode.c

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