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