fs/cifs/inode.c

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