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 out:
1380         kfree(path);
1381         free_xid(xid);
1382         return inode;
1383 }
1384
1385 int
1386 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1387                    const char *full_path, __u32 dosattr)
1388 {
1389         bool set_time = false;
1390         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1391         struct TCP_Server_Info *server;
1392         FILE_BASIC_INFO info_buf;
1393
1394         if (attrs == NULL)
1395                 return -EINVAL;
1396
1397         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1398         if (!server->ops->set_file_info)
1399                 return -ENOSYS;
1400
1401         info_buf.Pad = 0;
1402
1403         if (attrs->ia_valid & ATTR_ATIME) {
1404                 set_time = true;
1405                 info_buf.LastAccessTime =
1406                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1407         } else
1408                 info_buf.LastAccessTime = 0;
1409
1410         if (attrs->ia_valid & ATTR_MTIME) {
1411                 set_time = true;
1412                 info_buf.LastWriteTime =
1413                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1414         } else
1415                 info_buf.LastWriteTime = 0;
1416
1417         /*
1418          * Samba throws this field away, but windows may actually use it.
1419          * Do not set ctime unless other time stamps are changed explicitly
1420          * (i.e. by utimes()) since we would then have a mix of client and
1421          * server times.
1422          */
1423         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1424                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1425                 info_buf.ChangeTime =
1426                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1427         } else
1428                 info_buf.ChangeTime = 0;
1429
1430         info_buf.CreationTime = 0;      /* don't change */
1431         info_buf.Attributes = cpu_to_le32(dosattr);
1432
1433         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1434 }
1435
1436 /*
1437  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1438  * and rename it to a random name that hopefully won't conflict with
1439  * anything else.
1440  */
1441 int
1442 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1443                            const unsigned int xid)
1444 {
1445         int oplock = 0;
1446         int rc;
1447         struct cifs_fid fid;
1448         struct cifs_open_parms oparms;
1449         struct inode *inode = d_inode(dentry);
1450         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1451         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1452         struct tcon_link *tlink;
1453         struct cifs_tcon *tcon;
1454         __u32 dosattr, origattr;
1455         FILE_BASIC_INFO *info_buf = NULL;
1456
1457         tlink = cifs_sb_tlink(cifs_sb);
1458         if (IS_ERR(tlink))
1459                 return PTR_ERR(tlink);
1460         tcon = tlink_tcon(tlink);
1461
1462         /*
1463          * We cannot rename the file if the server doesn't support
1464          * CAP_INFOLEVEL_PASSTHRU
1465          */
1466         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1467                 rc = -EBUSY;
1468                 goto out;
1469         }
1470
1471         oparms.tcon = tcon;
1472         oparms.cifs_sb = cifs_sb;
1473         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1474         oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1475         oparms.disposition = FILE_OPEN;
1476         oparms.path = full_path;
1477         oparms.fid = &fid;
1478         oparms.reconnect = false;
1479
1480         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1481         if (rc != 0)
1482                 goto out;
1483
1484         origattr = cifsInode->cifsAttrs;
1485         if (origattr == 0)
1486                 origattr |= ATTR_NORMAL;
1487
1488         dosattr = origattr & ~ATTR_READONLY;
1489         if (dosattr == 0)
1490                 dosattr |= ATTR_NORMAL;
1491         dosattr |= ATTR_HIDDEN;
1492
1493         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1494         if (dosattr != origattr) {
1495                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1496                 if (info_buf == NULL) {
1497                         rc = -ENOMEM;
1498                         goto out_close;
1499                 }
1500                 info_buf->Attributes = cpu_to_le32(dosattr);
1501                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1502                                         current->tgid);
1503                 /* although we would like to mark the file hidden
1504                    if that fails we will still try to rename it */
1505                 if (!rc)
1506                         cifsInode->cifsAttrs = dosattr;
1507                 else
1508                         dosattr = origattr; /* since not able to change them */
1509         }
1510
1511         /* rename the file */
1512         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1513                                    cifs_sb->local_nls,
1514                                    cifs_remap(cifs_sb));
1515         if (rc != 0) {
1516                 rc = -EBUSY;
1517                 goto undo_setattr;
1518         }
1519
1520         /* try to set DELETE_ON_CLOSE */
1521         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1522                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1523                                                current->tgid);
1524                 /*
1525                  * some samba versions return -ENOENT when we try to set the
1526                  * file disposition here. Likely a samba bug, but work around
1527                  * it for now. This means that some cifsXXX files may hang
1528                  * around after they shouldn't.
1529                  *
1530                  * BB: remove this hack after more servers have the fix
1531                  */
1532                 if (rc == -ENOENT)
1533                         rc = 0;
1534                 else if (rc != 0) {
1535                         rc = -EBUSY;
1536                         goto undo_rename;
1537                 }
1538                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1539         }
1540
1541 out_close:
1542         CIFSSMBClose(xid, tcon, fid.netfid);
1543 out:
1544         kfree(info_buf);
1545         cifs_put_tlink(tlink);
1546         return rc;
1547
1548         /*
1549          * reset everything back to the original state. Don't bother
1550          * dealing with errors here since we can't do anything about
1551          * them anyway.
1552          */
1553 undo_rename:
1554         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1555                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1556 undo_setattr:
1557         if (dosattr != origattr) {
1558                 info_buf->Attributes = cpu_to_le32(origattr);
1559                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1560                                         current->tgid))
1561                         cifsInode->cifsAttrs = origattr;
1562         }
1563
1564         goto out_close;
1565 }
1566
1567 /* copied from fs/nfs/dir.c with small changes */
1568 static void
1569 cifs_drop_nlink(struct inode *inode)
1570 {
1571         spin_lock(&inode->i_lock);
1572         if (inode->i_nlink > 0)
1573                 drop_nlink(inode);
1574         spin_unlock(&inode->i_lock);
1575 }
1576
1577 /*
1578  * If d_inode(dentry) is null (usually meaning the cached dentry
1579  * is a negative dentry) then we would attempt a standard SMB delete, but
1580  * if that fails we can not attempt the fall back mechanisms on EACCES
1581  * but will return the EACCES to the caller. Note that the VFS does not call
1582  * unlink on negative dentries currently.
1583  */
1584 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1585 {
1586         int rc = 0;
1587         unsigned int xid;
1588         const char *full_path;
1589         void *page;
1590         struct inode *inode = d_inode(dentry);
1591         struct cifsInodeInfo *cifs_inode;
1592         struct super_block *sb = dir->i_sb;
1593         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1594         struct tcon_link *tlink;
1595         struct cifs_tcon *tcon;
1596         struct TCP_Server_Info *server;
1597         struct iattr *attrs = NULL;
1598         __u32 dosattr = 0, origattr = 0;
1599
1600         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1601
1602         if (unlikely(cifs_forced_shutdown(cifs_sb)))
1603                 return -EIO;
1604
1605         tlink = cifs_sb_tlink(cifs_sb);
1606         if (IS_ERR(tlink))
1607                 return PTR_ERR(tlink);
1608         tcon = tlink_tcon(tlink);
1609         server = tcon->ses->server;
1610
1611         xid = get_xid();
1612         page = alloc_dentry_path();
1613
1614         if (tcon->nodelete) {
1615                 rc = -EACCES;
1616                 goto unlink_out;
1617         }
1618
1619         /* Unlink can be called from rename so we can not take the
1620          * sb->s_vfs_rename_mutex here */
1621         full_path = build_path_from_dentry(dentry, page);
1622         if (IS_ERR(full_path)) {
1623                 rc = PTR_ERR(full_path);
1624                 goto unlink_out;
1625         }
1626
1627         cifs_close_deferred_file_under_dentry(tcon, full_path);
1628         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1629                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1630                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1631                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1632                         cifs_remap(cifs_sb));
1633                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1634                 if ((rc == 0) || (rc == -ENOENT))
1635                         goto psx_del_no_retry;
1636         }
1637
1638 retry_std_delete:
1639         if (!server->ops->unlink) {
1640                 rc = -ENOSYS;
1641                 goto psx_del_no_retry;
1642         }
1643
1644         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1645
1646 psx_del_no_retry:
1647         if (!rc) {
1648                 if (inode)
1649                         cifs_drop_nlink(inode);
1650         } else if (rc == -ENOENT) {
1651                 d_drop(dentry);
1652         } else if (rc == -EBUSY) {
1653                 if (server->ops->rename_pending_delete) {
1654                         rc = server->ops->rename_pending_delete(full_path,
1655                                                                 dentry, xid);
1656                         if (rc == 0)
1657                                 cifs_drop_nlink(inode);
1658                 }
1659         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1660                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1661                 if (attrs == NULL) {
1662                         rc = -ENOMEM;
1663                         goto out_reval;
1664                 }
1665
1666                 /* try to reset dos attributes */
1667                 cifs_inode = CIFS_I(inode);
1668                 origattr = cifs_inode->cifsAttrs;
1669                 if (origattr == 0)
1670                         origattr |= ATTR_NORMAL;
1671                 dosattr = origattr & ~ATTR_READONLY;
1672                 if (dosattr == 0)
1673                         dosattr |= ATTR_NORMAL;
1674                 dosattr |= ATTR_HIDDEN;
1675
1676                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1677                 if (rc != 0)
1678                         goto out_reval;
1679
1680                 goto retry_std_delete;
1681         }
1682
1683         /* undo the setattr if we errored out and it's needed */
1684         if (rc != 0 && dosattr != 0)
1685                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1686
1687 out_reval:
1688         if (inode) {
1689                 cifs_inode = CIFS_I(inode);
1690                 cifs_inode->time = 0;   /* will force revalidate to get info
1691                                            when needed */
1692                 inode->i_ctime = current_time(inode);
1693         }
1694         dir->i_ctime = dir->i_mtime = current_time(dir);
1695         cifs_inode = CIFS_I(dir);
1696         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1697 unlink_out:
1698         free_dentry_path(page);
1699         kfree(attrs);
1700         free_xid(xid);
1701         cifs_put_tlink(tlink);
1702         return rc;
1703 }
1704
1705 static int
1706 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1707                  const char *full_path, struct cifs_sb_info *cifs_sb,
1708                  struct cifs_tcon *tcon, const unsigned int xid)
1709 {
1710         int rc = 0;
1711         struct inode *inode = NULL;
1712
1713         if (tcon->posix_extensions)
1714                 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1715         else if (tcon->unix_ext)
1716                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1717                                               xid);
1718         else
1719                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1720                                          xid, NULL);
1721
1722         if (rc)
1723                 return rc;
1724
1725         if (!S_ISDIR(inode->i_mode)) {
1726                 /*
1727                  * mkdir succeeded, but another client has managed to remove the
1728                  * sucker and replace it with non-directory.  Return success,
1729                  * but don't leave the child in dcache.
1730                  */
1731                  iput(inode);
1732                  d_drop(dentry);
1733                  return 0;
1734         }
1735         /*
1736          * setting nlink not necessary except in cases where we failed to get it
1737          * from the server or was set bogus. Also, since this is a brand new
1738          * inode, no need to grab the i_lock before setting the i_nlink.
1739          */
1740         if (inode->i_nlink < 2)
1741                 set_nlink(inode, 2);
1742         mode &= ~current_umask();
1743         /* must turn on setgid bit if parent dir has it */
1744         if (parent->i_mode & S_ISGID)
1745                 mode |= S_ISGID;
1746
1747         if (tcon->unix_ext) {
1748                 struct cifs_unix_set_info_args args = {
1749                         .mode   = mode,
1750                         .ctime  = NO_CHANGE_64,
1751                         .atime  = NO_CHANGE_64,
1752                         .mtime  = NO_CHANGE_64,
1753                         .device = 0,
1754                 };
1755                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1756                         args.uid = current_fsuid();
1757                         if (parent->i_mode & S_ISGID)
1758                                 args.gid = parent->i_gid;
1759                         else
1760                                 args.gid = current_fsgid();
1761                 } else {
1762                         args.uid = INVALID_UID; /* no change */
1763                         args.gid = INVALID_GID; /* no change */
1764                 }
1765                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1766                                        cifs_sb->local_nls,
1767                                        cifs_remap(cifs_sb));
1768         } else {
1769                 struct TCP_Server_Info *server = tcon->ses->server;
1770                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1771                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1772                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1773                                                    tcon, xid);
1774                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1775                         inode->i_mode = (mode | S_IFDIR);
1776
1777                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1778                         inode->i_uid = current_fsuid();
1779                         if (inode->i_mode & S_ISGID)
1780                                 inode->i_gid = parent->i_gid;
1781                         else
1782                                 inode->i_gid = current_fsgid();
1783                 }
1784         }
1785         d_instantiate(dentry, inode);
1786         return 0;
1787 }
1788
1789 static int
1790 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1791                  const char *full_path, struct cifs_sb_info *cifs_sb,
1792                  struct cifs_tcon *tcon, const unsigned int xid)
1793 {
1794         int rc = 0;
1795         u32 oplock = 0;
1796         FILE_UNIX_BASIC_INFO *info = NULL;
1797         struct inode *newinode = NULL;
1798         struct cifs_fattr fattr;
1799
1800         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1801         if (info == NULL) {
1802                 rc = -ENOMEM;
1803                 goto posix_mkdir_out;
1804         }
1805
1806         mode &= ~current_umask();
1807         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1808                              NULL /* netfid */, info, &oplock, full_path,
1809                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1810         if (rc == -EOPNOTSUPP)
1811                 goto posix_mkdir_out;
1812         else if (rc) {
1813                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1814                 d_drop(dentry);
1815                 goto posix_mkdir_out;
1816         }
1817
1818         if (info->Type == cpu_to_le32(-1))
1819                 /* no return info, go query for it */
1820                 goto posix_mkdir_get_info;
1821         /*
1822          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1823          * need to set uid/gid.
1824          */
1825
1826         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1827         cifs_fill_uniqueid(inode->i_sb, &fattr);
1828         newinode = cifs_iget(inode->i_sb, &fattr);
1829         if (!newinode)
1830                 goto posix_mkdir_get_info;
1831
1832         d_instantiate(dentry, newinode);
1833
1834 #ifdef CONFIG_CIFS_DEBUG2
1835         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1836                  dentry, dentry, newinode);
1837
1838         if (newinode->i_nlink != 2)
1839                 cifs_dbg(FYI, "unexpected number of links %d\n",
1840                          newinode->i_nlink);
1841 #endif
1842
1843 posix_mkdir_out:
1844         kfree(info);
1845         return rc;
1846 posix_mkdir_get_info:
1847         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1848                               xid);
1849         goto posix_mkdir_out;
1850 }
1851
1852 int cifs_mkdir(struct user_namespace *mnt_userns, struct inode *inode,
1853                struct dentry *direntry, umode_t mode)
1854 {
1855         int rc = 0;
1856         unsigned int xid;
1857         struct cifs_sb_info *cifs_sb;
1858         struct tcon_link *tlink;
1859         struct cifs_tcon *tcon;
1860         struct TCP_Server_Info *server;
1861         const char *full_path;
1862         void *page;
1863
1864         cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1865                  mode, inode);
1866
1867         cifs_sb = CIFS_SB(inode->i_sb);
1868         if (unlikely(cifs_forced_shutdown(cifs_sb)))
1869                 return -EIO;
1870         tlink = cifs_sb_tlink(cifs_sb);
1871         if (IS_ERR(tlink))
1872                 return PTR_ERR(tlink);
1873         tcon = tlink_tcon(tlink);
1874
1875         xid = get_xid();
1876
1877         page = alloc_dentry_path();
1878         full_path = build_path_from_dentry(direntry, page);
1879         if (IS_ERR(full_path)) {
1880                 rc = PTR_ERR(full_path);
1881                 goto mkdir_out;
1882         }
1883
1884         server = tcon->ses->server;
1885
1886         if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1887                 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1888                                               cifs_sb);
1889                 d_drop(direntry); /* for time being always refresh inode info */
1890                 goto mkdir_out;
1891         }
1892
1893         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1894                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1895                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1896                                       tcon, xid);
1897                 if (rc != -EOPNOTSUPP)
1898                         goto mkdir_out;
1899         }
1900
1901         if (!server->ops->mkdir) {
1902                 rc = -ENOSYS;
1903                 goto mkdir_out;
1904         }
1905
1906         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1907         rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1908         if (rc) {
1909                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1910                 d_drop(direntry);
1911                 goto mkdir_out;
1912         }
1913
1914         /* TODO: skip this for smb2/smb3 */
1915         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1916                               xid);
1917 mkdir_out:
1918         /*
1919          * Force revalidate to get parent dir info when needed since cached
1920          * attributes are invalid now.
1921          */
1922         CIFS_I(inode)->time = 0;
1923         free_dentry_path(page);
1924         free_xid(xid);
1925         cifs_put_tlink(tlink);
1926         return rc;
1927 }
1928
1929 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1930 {
1931         int rc = 0;
1932         unsigned int xid;
1933         struct cifs_sb_info *cifs_sb;
1934         struct tcon_link *tlink;
1935         struct cifs_tcon *tcon;
1936         struct TCP_Server_Info *server;
1937         const char *full_path;
1938         void *page = alloc_dentry_path();
1939         struct cifsInodeInfo *cifsInode;
1940
1941         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1942
1943         xid = get_xid();
1944
1945         full_path = build_path_from_dentry(direntry, page);
1946         if (IS_ERR(full_path)) {
1947                 rc = PTR_ERR(full_path);
1948                 goto rmdir_exit;
1949         }
1950
1951         cifs_sb = CIFS_SB(inode->i_sb);
1952         if (unlikely(cifs_forced_shutdown(cifs_sb))) {
1953                 rc = -EIO;
1954                 goto rmdir_exit;
1955         }
1956
1957         tlink = cifs_sb_tlink(cifs_sb);
1958         if (IS_ERR(tlink)) {
1959                 rc = PTR_ERR(tlink);
1960                 goto rmdir_exit;
1961         }
1962         tcon = tlink_tcon(tlink);
1963         server = tcon->ses->server;
1964
1965         if (!server->ops->rmdir) {
1966                 rc = -ENOSYS;
1967                 cifs_put_tlink(tlink);
1968                 goto rmdir_exit;
1969         }
1970
1971         if (tcon->nodelete) {
1972                 rc = -EACCES;
1973                 cifs_put_tlink(tlink);
1974                 goto rmdir_exit;
1975         }
1976
1977         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1978         cifs_put_tlink(tlink);
1979
1980         if (!rc) {
1981                 spin_lock(&d_inode(direntry)->i_lock);
1982                 i_size_write(d_inode(direntry), 0);
1983                 clear_nlink(d_inode(direntry));
1984                 spin_unlock(&d_inode(direntry)->i_lock);
1985         }
1986
1987         cifsInode = CIFS_I(d_inode(direntry));
1988         /* force revalidate to go get info when needed */
1989         cifsInode->time = 0;
1990
1991         cifsInode = CIFS_I(inode);
1992         /*
1993          * Force revalidate to get parent dir info when needed since cached
1994          * attributes are invalid now.
1995          */
1996         cifsInode->time = 0;
1997
1998         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1999                 current_time(inode);
2000
2001 rmdir_exit:
2002         free_dentry_path(page);
2003         free_xid(xid);
2004         return rc;
2005 }
2006
2007 static int
2008 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2009                const char *from_path, struct dentry *to_dentry,
2010                const char *to_path)
2011 {
2012         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2013         struct tcon_link *tlink;
2014         struct cifs_tcon *tcon;
2015         struct TCP_Server_Info *server;
2016         struct cifs_fid fid;
2017         struct cifs_open_parms oparms;
2018         int oplock, rc;
2019
2020         tlink = cifs_sb_tlink(cifs_sb);
2021         if (IS_ERR(tlink))
2022                 return PTR_ERR(tlink);
2023         tcon = tlink_tcon(tlink);
2024         server = tcon->ses->server;
2025
2026         if (!server->ops->rename)
2027                 return -ENOSYS;
2028
2029         /* try path-based rename first */
2030         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
2031
2032         /*
2033          * Don't bother with rename by filehandle unless file is busy and
2034          * source. Note that cross directory moves do not work with
2035          * rename by filehandle to various Windows servers.
2036          */
2037         if (rc == 0 || rc != -EBUSY)
2038                 goto do_rename_exit;
2039
2040         /* Don't fall back to using SMB on SMB 2+ mount */
2041         if (server->vals->protocol_id != 0)
2042                 goto do_rename_exit;
2043
2044         /* open-file renames don't work across directories */
2045         if (to_dentry->d_parent != from_dentry->d_parent)
2046                 goto do_rename_exit;
2047
2048         oparms.tcon = tcon;
2049         oparms.cifs_sb = cifs_sb;
2050         /* open the file to be renamed -- we need DELETE perms */
2051         oparms.desired_access = DELETE;
2052         oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2053         oparms.disposition = FILE_OPEN;
2054         oparms.path = from_path;
2055         oparms.fid = &fid;
2056         oparms.reconnect = false;
2057
2058         rc = CIFS_open(xid, &oparms, &oplock, NULL);
2059         if (rc == 0) {
2060                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2061                                 (const char *) to_dentry->d_name.name,
2062                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
2063                 CIFSSMBClose(xid, tcon, fid.netfid);
2064         }
2065 do_rename_exit:
2066         if (rc == 0)
2067                 d_move(from_dentry, to_dentry);
2068         cifs_put_tlink(tlink);
2069         return rc;
2070 }
2071
2072 int
2073 cifs_rename2(struct user_namespace *mnt_userns, struct inode *source_dir,
2074              struct dentry *source_dentry, struct inode *target_dir,
2075              struct dentry *target_dentry, unsigned int flags)
2076 {
2077         const char *from_name, *to_name;
2078         void *page1, *page2;
2079         struct cifs_sb_info *cifs_sb;
2080         struct tcon_link *tlink;
2081         struct cifs_tcon *tcon;
2082         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2083         FILE_UNIX_BASIC_INFO *info_buf_target;
2084         unsigned int xid;
2085         int rc, tmprc;
2086         int retry_count = 0;
2087
2088         if (flags & ~RENAME_NOREPLACE)
2089                 return -EINVAL;
2090
2091         cifs_sb = CIFS_SB(source_dir->i_sb);
2092         if (unlikely(cifs_forced_shutdown(cifs_sb)))
2093                 return -EIO;
2094
2095         tlink = cifs_sb_tlink(cifs_sb);
2096         if (IS_ERR(tlink))
2097                 return PTR_ERR(tlink);
2098         tcon = tlink_tcon(tlink);
2099
2100         page1 = alloc_dentry_path();
2101         page2 = alloc_dentry_path();
2102         xid = get_xid();
2103
2104         from_name = build_path_from_dentry(source_dentry, page1);
2105         if (IS_ERR(from_name)) {
2106                 rc = PTR_ERR(from_name);
2107                 goto cifs_rename_exit;
2108         }
2109
2110         to_name = build_path_from_dentry(target_dentry, page2);
2111         if (IS_ERR(to_name)) {
2112                 rc = PTR_ERR(to_name);
2113                 goto cifs_rename_exit;
2114         }
2115
2116         cifs_close_deferred_file_under_dentry(tcon, from_name);
2117         if (d_inode(target_dentry) != NULL)
2118                 cifs_close_deferred_file_under_dentry(tcon, to_name);
2119
2120         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2121                             to_name);
2122
2123         if (rc == -EACCES) {
2124                 while (retry_count < 3) {
2125                         cifs_close_all_deferred_files(tcon);
2126                         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2127                                             to_name);
2128                         if (rc != -EACCES)
2129                                 break;
2130                         retry_count++;
2131                 }
2132         }
2133
2134         /*
2135          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2136          */
2137         if (flags & RENAME_NOREPLACE)
2138                 goto cifs_rename_exit;
2139
2140         if (rc == -EEXIST && tcon->unix_ext) {
2141                 /*
2142                  * Are src and dst hardlinks of same inode? We can only tell
2143                  * with unix extensions enabled.
2144                  */
2145                 info_buf_source =
2146                         kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2147                                         GFP_KERNEL);
2148                 if (info_buf_source == NULL) {
2149                         rc = -ENOMEM;
2150                         goto cifs_rename_exit;
2151                 }
2152
2153                 info_buf_target = info_buf_source + 1;
2154                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2155                                              info_buf_source,
2156                                              cifs_sb->local_nls,
2157                                              cifs_remap(cifs_sb));
2158                 if (tmprc != 0)
2159                         goto unlink_target;
2160
2161                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2162                                              info_buf_target,
2163                                              cifs_sb->local_nls,
2164                                              cifs_remap(cifs_sb));
2165
2166                 if (tmprc == 0 && (info_buf_source->UniqueId ==
2167                                    info_buf_target->UniqueId)) {
2168                         /* same file, POSIX says that this is a noop */
2169                         rc = 0;
2170                         goto cifs_rename_exit;
2171                 }
2172         }
2173         /*
2174          * else ... BB we could add the same check for Windows by
2175          * checking the UniqueId via FILE_INTERNAL_INFO
2176          */
2177
2178 unlink_target:
2179         /* Try unlinking the target dentry if it's not negative */
2180         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2181                 if (d_is_dir(target_dentry))
2182                         tmprc = cifs_rmdir(target_dir, target_dentry);
2183                 else
2184                         tmprc = cifs_unlink(target_dir, target_dentry);
2185                 if (tmprc)
2186                         goto cifs_rename_exit;
2187                 rc = cifs_do_rename(xid, source_dentry, from_name,
2188                                     target_dentry, to_name);
2189         }
2190
2191         /* force revalidate to go get info when needed */
2192         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2193
2194         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2195                 target_dir->i_mtime = current_time(source_dir);
2196
2197 cifs_rename_exit:
2198         kfree(info_buf_source);
2199         free_dentry_path(page2);
2200         free_dentry_path(page1);
2201         free_xid(xid);
2202         cifs_put_tlink(tlink);
2203         return rc;
2204 }
2205
2206 static bool
2207 cifs_dentry_needs_reval(struct dentry *dentry)
2208 {
2209         struct inode *inode = d_inode(dentry);
2210         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2211         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2212         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2213         struct cached_fid *cfid = NULL;
2214
2215         if (cifs_i->time == 0)
2216                 return true;
2217
2218         if (CIFS_CACHE_READ(cifs_i))
2219                 return false;
2220
2221         if (!lookupCacheEnabled)
2222                 return true;
2223
2224         if (!open_cached_dir_by_dentry(tcon, dentry->d_parent, &cfid)) {
2225                 mutex_lock(&cfid->fid_mutex);
2226                 if (cfid->time && cifs_i->time > cfid->time) {
2227                         mutex_unlock(&cfid->fid_mutex);
2228                         close_cached_dir(cfid);
2229                         return false;
2230                 }
2231                 mutex_unlock(&cfid->fid_mutex);
2232                 close_cached_dir(cfid);
2233         }
2234         /*
2235          * depending on inode type, check if attribute caching disabled for
2236          * files or directories
2237          */
2238         if (S_ISDIR(inode->i_mode)) {
2239                 if (!cifs_sb->ctx->acdirmax)
2240                         return true;
2241                 if (!time_in_range(jiffies, cifs_i->time,
2242                                    cifs_i->time + cifs_sb->ctx->acdirmax))
2243                         return true;
2244         } else { /* file */
2245                 if (!cifs_sb->ctx->acregmax)
2246                         return true;
2247                 if (!time_in_range(jiffies, cifs_i->time,
2248                                    cifs_i->time + cifs_sb->ctx->acregmax))
2249                         return true;
2250         }
2251
2252         /* hardlinked files w/ noserverino get "special" treatment */
2253         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2254             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2255                 return true;
2256
2257         return false;
2258 }
2259
2260 /*
2261  * Zap the cache. Called when invalid_mapping flag is set.
2262  */
2263 int
2264 cifs_invalidate_mapping(struct inode *inode)
2265 {
2266         int rc = 0;
2267
2268         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2269                 rc = invalidate_inode_pages2(inode->i_mapping);
2270                 if (rc)
2271                         cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2272                                  __func__, inode);
2273         }
2274
2275         cifs_fscache_reset_inode_cookie(inode);
2276         return rc;
2277 }
2278
2279 /**
2280  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2281  *
2282  * @key:        currently unused
2283  * @mode:       the task state to sleep in
2284  */
2285 static int
2286 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2287 {
2288         freezable_schedule_unsafe();
2289         if (signal_pending_state(mode, current))
2290                 return -ERESTARTSYS;
2291         return 0;
2292 }
2293
2294 int
2295 cifs_revalidate_mapping(struct inode *inode)
2296 {
2297         int rc;
2298         unsigned long *flags = &CIFS_I(inode)->flags;
2299         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2300
2301         /* swapfiles are not supposed to be shared */
2302         if (IS_SWAPFILE(inode))
2303                 return 0;
2304
2305         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2306                                      TASK_KILLABLE);
2307         if (rc)
2308                 return rc;
2309
2310         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2311                 /* for cache=singleclient, do not invalidate */
2312                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RW_CACHE)
2313                         goto skip_invalidate;
2314
2315                 rc = cifs_invalidate_mapping(inode);
2316                 if (rc)
2317                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
2318         }
2319
2320 skip_invalidate:
2321         clear_bit_unlock(CIFS_INO_LOCK, flags);
2322         smp_mb__after_atomic();
2323         wake_up_bit(flags, CIFS_INO_LOCK);
2324
2325         return rc;
2326 }
2327
2328 int
2329 cifs_zap_mapping(struct inode *inode)
2330 {
2331         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2332         return cifs_revalidate_mapping(inode);
2333 }
2334
2335 int cifs_revalidate_file_attr(struct file *filp)
2336 {
2337         int rc = 0;
2338         struct dentry *dentry = file_dentry(filp);
2339         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2340
2341         if (!cifs_dentry_needs_reval(dentry))
2342                 return rc;
2343
2344         if (tlink_tcon(cfile->tlink)->unix_ext)
2345                 rc = cifs_get_file_info_unix(filp);
2346         else
2347                 rc = cifs_get_file_info(filp);
2348
2349         return rc;
2350 }
2351
2352 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2353 {
2354         unsigned int xid;
2355         int rc = 0;
2356         struct inode *inode = d_inode(dentry);
2357         struct super_block *sb = dentry->d_sb;
2358         const char *full_path;
2359         void *page;
2360         int count = 0;
2361
2362         if (inode == NULL)
2363                 return -ENOENT;
2364
2365         if (!cifs_dentry_needs_reval(dentry))
2366                 return rc;
2367
2368         xid = get_xid();
2369
2370         page = alloc_dentry_path();
2371         full_path = build_path_from_dentry(dentry, page);
2372         if (IS_ERR(full_path)) {
2373                 rc = PTR_ERR(full_path);
2374                 goto out;
2375         }
2376
2377         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2378                  full_path, inode, inode->i_count.counter,
2379                  dentry, cifs_get_time(dentry), jiffies);
2380
2381 again:
2382         if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2383                 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2384         else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2385                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2386         else
2387                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2388                                          xid, NULL);
2389         if (rc == -EAGAIN && count++ < 10)
2390                 goto again;
2391 out:
2392         free_dentry_path(page);
2393         free_xid(xid);
2394
2395         return rc;
2396 }
2397
2398 int cifs_revalidate_file(struct file *filp)
2399 {
2400         int rc;
2401         struct inode *inode = file_inode(filp);
2402
2403         rc = cifs_revalidate_file_attr(filp);
2404         if (rc)
2405                 return rc;
2406
2407         return cifs_revalidate_mapping(inode);
2408 }
2409
2410 /* revalidate a dentry's inode attributes */
2411 int cifs_revalidate_dentry(struct dentry *dentry)
2412 {
2413         int rc;
2414         struct inode *inode = d_inode(dentry);
2415
2416         rc = cifs_revalidate_dentry_attr(dentry);
2417         if (rc)
2418                 return rc;
2419
2420         return cifs_revalidate_mapping(inode);
2421 }
2422
2423 int cifs_getattr(struct user_namespace *mnt_userns, const struct path *path,
2424                  struct kstat *stat, u32 request_mask, unsigned int flags)
2425 {
2426         struct dentry *dentry = path->dentry;
2427         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2428         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2429         struct inode *inode = d_inode(dentry);
2430         int rc;
2431
2432         if (unlikely(cifs_forced_shutdown(CIFS_SB(inode->i_sb))))
2433                 return -EIO;
2434
2435         /*
2436          * We need to be sure that all dirty pages are written and the server
2437          * has actual ctime, mtime and file length.
2438          */
2439         if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE | STATX_BLOCKS)) &&
2440             !CIFS_CACHE_READ(CIFS_I(inode)) &&
2441             inode->i_mapping && inode->i_mapping->nrpages != 0) {
2442                 rc = filemap_fdatawait(inode->i_mapping);
2443                 if (rc) {
2444                         mapping_set_error(inode->i_mapping, rc);
2445                         return rc;
2446                 }
2447         }
2448
2449         if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2450                 CIFS_I(inode)->time = 0; /* force revalidate */
2451
2452         /*
2453          * If the caller doesn't require syncing, only sync if
2454          * necessary (e.g. due to earlier truncate or setattr
2455          * invalidating the cached metadata)
2456          */
2457         if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2458             (CIFS_I(inode)->time == 0)) {
2459                 rc = cifs_revalidate_dentry_attr(dentry);
2460                 if (rc)
2461                         return rc;
2462         }
2463
2464         generic_fillattr(&init_user_ns, inode, stat);
2465         stat->blksize = cifs_sb->ctx->bsize;
2466         stat->ino = CIFS_I(inode)->uniqueid;
2467
2468         /* old CIFS Unix Extensions doesn't return create time */
2469         if (CIFS_I(inode)->createtime) {
2470                 stat->result_mask |= STATX_BTIME;
2471                 stat->btime =
2472                       cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2473         }
2474
2475         stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2476         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2477                 stat->attributes |= STATX_ATTR_COMPRESSED;
2478         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2479                 stat->attributes |= STATX_ATTR_ENCRYPTED;
2480
2481         /*
2482          * If on a multiuser mount without unix extensions or cifsacl being
2483          * enabled, and the admin hasn't overridden them, set the ownership
2484          * to the fsuid/fsgid of the current process.
2485          */
2486         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2487             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2488             !tcon->unix_ext) {
2489                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2490                         stat->uid = current_fsuid();
2491                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2492                         stat->gid = current_fsgid();
2493         }
2494         return 0;
2495 }
2496
2497 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2498                 u64 len)
2499 {
2500         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2501         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2502         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2503         struct TCP_Server_Info *server = tcon->ses->server;
2504         struct cifsFileInfo *cfile;
2505         int rc;
2506
2507         if (unlikely(cifs_forced_shutdown(cifs_sb)))
2508                 return -EIO;
2509
2510         /*
2511          * We need to be sure that all dirty pages are written as they
2512          * might fill holes on the server.
2513          */
2514         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2515             inode->i_mapping->nrpages != 0) {
2516                 rc = filemap_fdatawait(inode->i_mapping);
2517                 if (rc) {
2518                         mapping_set_error(inode->i_mapping, rc);
2519                         return rc;
2520                 }
2521         }
2522
2523         cfile = find_readable_file(cifs_i, false);
2524         if (cfile == NULL)
2525                 return -EINVAL;
2526
2527         if (server->ops->fiemap) {
2528                 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2529                 cifsFileInfo_put(cfile);
2530                 return rc;
2531         }
2532
2533         cifsFileInfo_put(cfile);
2534         return -ENOTSUPP;
2535 }
2536
2537 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2538 {
2539         pgoff_t index = from >> PAGE_SHIFT;
2540         unsigned offset = from & (PAGE_SIZE - 1);
2541         struct page *page;
2542         int rc = 0;
2543
2544         page = grab_cache_page(mapping, index);
2545         if (!page)
2546                 return -ENOMEM;
2547
2548         zero_user_segment(page, offset, PAGE_SIZE);
2549         unlock_page(page);
2550         put_page(page);
2551         return rc;
2552 }
2553
2554 void cifs_setsize(struct inode *inode, loff_t offset)
2555 {
2556         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2557
2558         spin_lock(&inode->i_lock);
2559         i_size_write(inode, offset);
2560         spin_unlock(&inode->i_lock);
2561
2562         /* Cached inode must be refreshed on truncate */
2563         cifs_i->time = 0;
2564         truncate_pagecache(inode, offset);
2565 }
2566
2567 static int
2568 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2569                    unsigned int xid, const char *full_path)
2570 {
2571         int rc;
2572         struct cifsFileInfo *open_file;
2573         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2574         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2575         struct tcon_link *tlink = NULL;
2576         struct cifs_tcon *tcon = NULL;
2577         struct TCP_Server_Info *server;
2578
2579         /*
2580          * To avoid spurious oplock breaks from server, in the case of
2581          * inodes that we already have open, avoid doing path based
2582          * setting of file size if we can do it by handle.
2583          * This keeps our caching token (oplock) and avoids timeouts
2584          * when the local oplock break takes longer to flush
2585          * writebehind data than the SMB timeout for the SetPathInfo
2586          * request would allow
2587          */
2588         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2589         if (open_file) {
2590                 tcon = tlink_tcon(open_file->tlink);
2591                 server = tcon->ses->server;
2592                 if (server->ops->set_file_size)
2593                         rc = server->ops->set_file_size(xid, tcon, open_file,
2594                                                         attrs->ia_size, false);
2595                 else
2596                         rc = -ENOSYS;
2597                 cifsFileInfo_put(open_file);
2598                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2599         } else
2600                 rc = -EINVAL;
2601
2602         if (!rc)
2603                 goto set_size_out;
2604
2605         if (tcon == NULL) {
2606                 tlink = cifs_sb_tlink(cifs_sb);
2607                 if (IS_ERR(tlink))
2608                         return PTR_ERR(tlink);
2609                 tcon = tlink_tcon(tlink);
2610                 server = tcon->ses->server;
2611         }
2612
2613         /*
2614          * Set file size by pathname rather than by handle either because no
2615          * valid, writeable file handle for it was found or because there was
2616          * an error setting it by handle.
2617          */
2618         if (server->ops->set_path_size)
2619                 rc = server->ops->set_path_size(xid, tcon, full_path,
2620                                                 attrs->ia_size, cifs_sb, false);
2621         else
2622                 rc = -ENOSYS;
2623         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2624
2625         if (tlink)
2626                 cifs_put_tlink(tlink);
2627
2628 set_size_out:
2629         if (rc == 0) {
2630                 cifsInode->server_eof = attrs->ia_size;
2631                 cifs_setsize(inode, attrs->ia_size);
2632                 /*
2633                  * i_blocks is not related to (i_size / i_blksize), but instead
2634                  * 512 byte (2**9) size is required for calculating num blocks.
2635                  * Until we can query the server for actual allocation size,
2636                  * this is best estimate we have for blocks allocated for a file
2637                  * Number of blocks must be rounded up so size 1 is not 0 blocks
2638                  */
2639                 inode->i_blocks = (512 - 1 + attrs->ia_size) >> 9;
2640
2641                 /*
2642                  * The man page of truncate says if the size changed,
2643                  * then the st_ctime and st_mtime fields for the file
2644                  * are updated.
2645                  */
2646                 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2647                 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2648
2649                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2650         }
2651
2652         return rc;
2653 }
2654
2655 static int
2656 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2657 {
2658         int rc;
2659         unsigned int xid;
2660         const char *full_path;
2661         void *page = alloc_dentry_path();
2662         struct inode *inode = d_inode(direntry);
2663         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2664         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2665         struct tcon_link *tlink;
2666         struct cifs_tcon *pTcon;
2667         struct cifs_unix_set_info_args *args = NULL;
2668         struct cifsFileInfo *open_file;
2669
2670         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2671                  direntry, attrs->ia_valid);
2672
2673         xid = get_xid();
2674
2675         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2676                 attrs->ia_valid |= ATTR_FORCE;
2677
2678         rc = setattr_prepare(&init_user_ns, direntry, attrs);
2679         if (rc < 0)
2680                 goto out;
2681
2682         full_path = build_path_from_dentry(direntry, page);
2683         if (IS_ERR(full_path)) {
2684                 rc = PTR_ERR(full_path);
2685                 goto out;
2686         }
2687
2688         /*
2689          * Attempt to flush data before changing attributes. We need to do
2690          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2691          * ownership or mode then we may also need to do this. Here, we take
2692          * the safe way out and just do the flush on all setattr requests. If
2693          * the flush returns error, store it to report later and continue.
2694          *
2695          * BB: This should be smarter. Why bother flushing pages that
2696          * will be truncated anyway? Also, should we error out here if
2697          * the flush returns error?
2698          */
2699         rc = filemap_write_and_wait(inode->i_mapping);
2700         if (is_interrupt_error(rc)) {
2701                 rc = -ERESTARTSYS;
2702                 goto out;
2703         }
2704
2705         mapping_set_error(inode->i_mapping, rc);
2706         rc = 0;
2707
2708         if (attrs->ia_valid & ATTR_SIZE) {
2709                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2710                 if (rc != 0)
2711                         goto out;
2712         }
2713
2714         /* skip mode change if it's just for clearing setuid/setgid */
2715         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2716                 attrs->ia_valid &= ~ATTR_MODE;
2717
2718         args = kmalloc(sizeof(*args), GFP_KERNEL);
2719         if (args == NULL) {
2720                 rc = -ENOMEM;
2721                 goto out;
2722         }
2723
2724         /* set up the struct */
2725         if (attrs->ia_valid & ATTR_MODE)
2726                 args->mode = attrs->ia_mode;
2727         else
2728                 args->mode = NO_CHANGE_64;
2729
2730         if (attrs->ia_valid & ATTR_UID)
2731                 args->uid = attrs->ia_uid;
2732         else
2733                 args->uid = INVALID_UID; /* no change */
2734
2735         if (attrs->ia_valid & ATTR_GID)
2736                 args->gid = attrs->ia_gid;
2737         else
2738                 args->gid = INVALID_GID; /* no change */
2739
2740         if (attrs->ia_valid & ATTR_ATIME)
2741                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2742         else
2743                 args->atime = NO_CHANGE_64;
2744
2745         if (attrs->ia_valid & ATTR_MTIME)
2746                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2747         else
2748                 args->mtime = NO_CHANGE_64;
2749
2750         if (attrs->ia_valid & ATTR_CTIME)
2751                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2752         else
2753                 args->ctime = NO_CHANGE_64;
2754
2755         args->device = 0;
2756         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2757         if (open_file) {
2758                 u16 nfid = open_file->fid.netfid;
2759                 u32 npid = open_file->pid;
2760                 pTcon = tlink_tcon(open_file->tlink);
2761                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2762                 cifsFileInfo_put(open_file);
2763         } else {
2764                 tlink = cifs_sb_tlink(cifs_sb);
2765                 if (IS_ERR(tlink)) {
2766                         rc = PTR_ERR(tlink);
2767                         goto out;
2768                 }
2769                 pTcon = tlink_tcon(tlink);
2770                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2771                                     cifs_sb->local_nls,
2772                                     cifs_remap(cifs_sb));
2773                 cifs_put_tlink(tlink);
2774         }
2775
2776         if (rc)
2777                 goto out;
2778
2779         if ((attrs->ia_valid & ATTR_SIZE) &&
2780             attrs->ia_size != i_size_read(inode))
2781                 truncate_setsize(inode, attrs->ia_size);
2782
2783         setattr_copy(&init_user_ns, inode, attrs);
2784         mark_inode_dirty(inode);
2785
2786         /* force revalidate when any of these times are set since some
2787            of the fs types (eg ext3, fat) do not have fine enough
2788            time granularity to match protocol, and we do not have a
2789            a way (yet) to query the server fs's time granularity (and
2790            whether it rounds times down).
2791         */
2792         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2793                 cifsInode->time = 0;
2794 out:
2795         kfree(args);
2796         free_dentry_path(page);
2797         free_xid(xid);
2798         return rc;
2799 }
2800
2801 static int
2802 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2803 {
2804         unsigned int xid;
2805         kuid_t uid = INVALID_UID;
2806         kgid_t gid = INVALID_GID;
2807         struct inode *inode = d_inode(direntry);
2808         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2809         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2810         struct cifsFileInfo *wfile;
2811         struct cifs_tcon *tcon;
2812         const char *full_path;
2813         void *page = alloc_dentry_path();
2814         int rc = -EACCES;
2815         __u32 dosattr = 0;
2816         __u64 mode = NO_CHANGE_64;
2817
2818         xid = get_xid();
2819
2820         cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2821                  direntry, attrs->ia_valid);
2822
2823         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2824                 attrs->ia_valid |= ATTR_FORCE;
2825
2826         rc = setattr_prepare(&init_user_ns, direntry, attrs);
2827         if (rc < 0)
2828                 goto cifs_setattr_exit;
2829
2830         full_path = build_path_from_dentry(direntry, page);
2831         if (IS_ERR(full_path)) {
2832                 rc = PTR_ERR(full_path);
2833                 goto cifs_setattr_exit;
2834         }
2835
2836         /*
2837          * Attempt to flush data before changing attributes. We need to do
2838          * this for ATTR_SIZE and ATTR_MTIME.  If the flush of the data
2839          * returns error, store it to report later and continue.
2840          *
2841          * BB: This should be smarter. Why bother flushing pages that
2842          * will be truncated anyway? Also, should we error out here if
2843          * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2844          */
2845         if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2846                 rc = filemap_write_and_wait(inode->i_mapping);
2847                 if (is_interrupt_error(rc)) {
2848                         rc = -ERESTARTSYS;
2849                         goto cifs_setattr_exit;
2850                 }
2851                 mapping_set_error(inode->i_mapping, rc);
2852         }
2853
2854         rc = 0;
2855
2856         if ((attrs->ia_valid & ATTR_MTIME) &&
2857             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2858                 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2859                 if (!rc) {
2860                         tcon = tlink_tcon(wfile->tlink);
2861                         rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2862                         cifsFileInfo_put(wfile);
2863                         if (rc)
2864                                 goto cifs_setattr_exit;
2865                 } else if (rc != -EBADF)
2866                         goto cifs_setattr_exit;
2867                 else
2868                         rc = 0;
2869         }
2870
2871         if (attrs->ia_valid & ATTR_SIZE) {
2872                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2873                 if (rc != 0)
2874                         goto cifs_setattr_exit;
2875         }
2876
2877         if (attrs->ia_valid & ATTR_UID)
2878                 uid = attrs->ia_uid;
2879
2880         if (attrs->ia_valid & ATTR_GID)
2881                 gid = attrs->ia_gid;
2882
2883         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2884             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2885                 if (uid_valid(uid) || gid_valid(gid)) {
2886                         mode = NO_CHANGE_64;
2887                         rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2888                                                         uid, gid);
2889                         if (rc) {
2890                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2891                                          __func__, rc);
2892                                 goto cifs_setattr_exit;
2893                         }
2894                 }
2895         } else
2896         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2897                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2898
2899         /* skip mode change if it's just for clearing setuid/setgid */
2900         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2901                 attrs->ia_valid &= ~ATTR_MODE;
2902
2903         if (attrs->ia_valid & ATTR_MODE) {
2904                 mode = attrs->ia_mode;
2905                 rc = 0;
2906                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2907                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2908                         rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2909                                                 INVALID_UID, INVALID_GID);
2910                         if (rc) {
2911                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2912                                          __func__, rc);
2913                                 goto cifs_setattr_exit;
2914                         }
2915
2916                         /*
2917                          * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
2918                          * Pick up the actual mode bits that were set.
2919                          */
2920                         if (mode != attrs->ia_mode)
2921                                 attrs->ia_mode = mode;
2922                 } else
2923                 if (((mode & S_IWUGO) == 0) &&
2924                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2925
2926                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2927
2928                         /* fix up mode if we're not using dynperm */
2929                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2930                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2931                 } else if ((mode & S_IWUGO) &&
2932                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2933
2934                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2935                         /* Attributes of 0 are ignored */
2936                         if (dosattr == 0)
2937                                 dosattr |= ATTR_NORMAL;
2938
2939                         /* reset local inode permissions to normal */
2940                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2941                                 attrs->ia_mode &= ~(S_IALLUGO);
2942                                 if (S_ISDIR(inode->i_mode))
2943                                         attrs->ia_mode |=
2944                                                 cifs_sb->ctx->dir_mode;
2945                                 else
2946                                         attrs->ia_mode |=
2947                                                 cifs_sb->ctx->file_mode;
2948                         }
2949                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2950                         /* ignore mode change - ATTR_READONLY hasn't changed */
2951                         attrs->ia_valid &= ~ATTR_MODE;
2952                 }
2953         }
2954
2955         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2956             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2957                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2958                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2959
2960                 /* Even if error on time set, no sense failing the call if
2961                 the server would set the time to a reasonable value anyway,
2962                 and this check ensures that we are not being called from
2963                 sys_utimes in which case we ought to fail the call back to
2964                 the user when the server rejects the call */
2965                 if ((rc) && (attrs->ia_valid &
2966                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2967                         rc = 0;
2968         }
2969
2970         /* do not need local check to inode_check_ok since the server does
2971            that */
2972         if (rc)
2973                 goto cifs_setattr_exit;
2974
2975         if ((attrs->ia_valid & ATTR_SIZE) &&
2976             attrs->ia_size != i_size_read(inode))
2977                 truncate_setsize(inode, attrs->ia_size);
2978
2979         setattr_copy(&init_user_ns, inode, attrs);
2980         mark_inode_dirty(inode);
2981
2982 cifs_setattr_exit:
2983         free_xid(xid);
2984         free_dentry_path(page);
2985         return rc;
2986 }
2987
2988 int
2989 cifs_setattr(struct user_namespace *mnt_userns, struct dentry *direntry,
2990              struct iattr *attrs)
2991 {
2992         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2993         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2994         int rc, retries = 0;
2995
2996         if (unlikely(cifs_forced_shutdown(cifs_sb)))
2997                 return -EIO;
2998
2999         do {
3000                 if (pTcon->unix_ext)
3001                         rc = cifs_setattr_unix(direntry, attrs);
3002                 else
3003                         rc = cifs_setattr_nounix(direntry, attrs);
3004                 retries++;
3005         } while (is_retryable_error(rc) && retries < 2);
3006
3007         /* BB: add cifs_setattr_legacy for really old servers */
3008         return rc;
3009 }