fs/cifs/inode.c

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