fs/smb/client/inode.c

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