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