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 inode *inode, struct dentry *direntry, umode_t mode)
1861 {
1862         int rc = 0;
1863         unsigned int xid;
1864         struct cifs_sb_info *cifs_sb;
1865         struct tcon_link *tlink;
1866         struct cifs_tcon *tcon;
1867         struct TCP_Server_Info *server;
1868         char *full_path;
1869
1870         cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1871                  mode, inode);
1872
1873         cifs_sb = CIFS_SB(inode->i_sb);
1874         tlink = cifs_sb_tlink(cifs_sb);
1875         if (IS_ERR(tlink))
1876                 return PTR_ERR(tlink);
1877         tcon = tlink_tcon(tlink);
1878
1879         xid = get_xid();
1880
1881         full_path = build_path_from_dentry(direntry);
1882         if (full_path == NULL) {
1883                 rc = -ENOMEM;
1884                 goto mkdir_out;
1885         }
1886
1887         server = tcon->ses->server;
1888
1889         if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1890                 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1891                                               cifs_sb);
1892                 d_drop(direntry); /* for time being always refresh inode info */
1893                 goto mkdir_out;
1894         }
1895
1896         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1897                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1898                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1899                                       tcon, xid);
1900                 if (rc != -EOPNOTSUPP)
1901                         goto mkdir_out;
1902         }
1903
1904         if (!server->ops->mkdir) {
1905                 rc = -ENOSYS;
1906                 goto mkdir_out;
1907         }
1908
1909         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1910         rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1911         if (rc) {
1912                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1913                 d_drop(direntry);
1914                 goto mkdir_out;
1915         }
1916
1917         /* TODO: skip this for smb2/smb3 */
1918         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1919                               xid);
1920 mkdir_out:
1921         /*
1922          * Force revalidate to get parent dir info when needed since cached
1923          * attributes are invalid now.
1924          */
1925         CIFS_I(inode)->time = 0;
1926         kfree(full_path);
1927         free_xid(xid);
1928         cifs_put_tlink(tlink);
1929         return rc;
1930 }
1931
1932 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1933 {
1934         int rc = 0;
1935         unsigned int xid;
1936         struct cifs_sb_info *cifs_sb;
1937         struct tcon_link *tlink;
1938         struct cifs_tcon *tcon;
1939         struct TCP_Server_Info *server;
1940         char *full_path = NULL;
1941         struct cifsInodeInfo *cifsInode;
1942
1943         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1944
1945         xid = get_xid();
1946
1947         full_path = build_path_from_dentry(direntry);
1948         if (full_path == NULL) {
1949                 rc = -ENOMEM;
1950                 goto rmdir_exit;
1951         }
1952
1953         cifs_sb = CIFS_SB(inode->i_sb);
1954         tlink = cifs_sb_tlink(cifs_sb);
1955         if (IS_ERR(tlink)) {
1956                 rc = PTR_ERR(tlink);
1957                 goto rmdir_exit;
1958         }
1959         tcon = tlink_tcon(tlink);
1960         server = tcon->ses->server;
1961
1962         if (!server->ops->rmdir) {
1963                 rc = -ENOSYS;
1964                 cifs_put_tlink(tlink);
1965                 goto rmdir_exit;
1966         }
1967
1968         if (tcon->nodelete) {
1969                 rc = -EACCES;
1970                 cifs_put_tlink(tlink);
1971                 goto rmdir_exit;
1972         }
1973
1974         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1975         cifs_put_tlink(tlink);
1976
1977         if (!rc) {
1978                 spin_lock(&d_inode(direntry)->i_lock);
1979                 i_size_write(d_inode(direntry), 0);
1980                 clear_nlink(d_inode(direntry));
1981                 spin_unlock(&d_inode(direntry)->i_lock);
1982         }
1983
1984         cifsInode = CIFS_I(d_inode(direntry));
1985         /* force revalidate to go get info when needed */
1986         cifsInode->time = 0;
1987
1988         cifsInode = CIFS_I(inode);
1989         /*
1990          * Force revalidate to get parent dir info when needed since cached
1991          * attributes are invalid now.
1992          */
1993         cifsInode->time = 0;
1994
1995         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1996                 current_time(inode);
1997
1998 rmdir_exit:
1999         kfree(full_path);
2000         free_xid(xid);
2001         return rc;
2002 }
2003
2004 static int
2005 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
2006                const char *from_path, struct dentry *to_dentry,
2007                const char *to_path)
2008 {
2009         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
2010         struct tcon_link *tlink;
2011         struct cifs_tcon *tcon;
2012         struct TCP_Server_Info *server;
2013         struct cifs_fid fid;
2014         struct cifs_open_parms oparms;
2015         int oplock, rc;
2016
2017         tlink = cifs_sb_tlink(cifs_sb);
2018         if (IS_ERR(tlink))
2019                 return PTR_ERR(tlink);
2020         tcon = tlink_tcon(tlink);
2021         server = tcon->ses->server;
2022
2023         if (!server->ops->rename)
2024                 return -ENOSYS;
2025
2026         /* try path-based rename first */
2027         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
2028
2029         /*
2030          * Don't bother with rename by filehandle unless file is busy and
2031          * source. Note that cross directory moves do not work with
2032          * rename by filehandle to various Windows servers.
2033          */
2034         if (rc == 0 || rc != -EBUSY)
2035                 goto do_rename_exit;
2036
2037         /* Don't fall back to using SMB on SMB 2+ mount */
2038         if (server->vals->protocol_id != 0)
2039                 goto do_rename_exit;
2040
2041         /* open-file renames don't work across directories */
2042         if (to_dentry->d_parent != from_dentry->d_parent)
2043                 goto do_rename_exit;
2044
2045         oparms.tcon = tcon;
2046         oparms.cifs_sb = cifs_sb;
2047         /* open the file to be renamed -- we need DELETE perms */
2048         oparms.desired_access = DELETE;
2049         oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2050         oparms.disposition = FILE_OPEN;
2051         oparms.path = from_path;
2052         oparms.fid = &fid;
2053         oparms.reconnect = false;
2054
2055         rc = CIFS_open(xid, &oparms, &oplock, NULL);
2056         if (rc == 0) {
2057                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2058                                 (const char *) to_dentry->d_name.name,
2059                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
2060                 CIFSSMBClose(xid, tcon, fid.netfid);
2061         }
2062 do_rename_exit:
2063         if (rc == 0)
2064                 d_move(from_dentry, to_dentry);
2065         cifs_put_tlink(tlink);
2066         return rc;
2067 }
2068
2069 int
2070 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
2071              struct inode *target_dir, struct dentry *target_dentry,
2072              unsigned int flags)
2073 {
2074         char *from_name = NULL;
2075         char *to_name = NULL;
2076         struct cifs_sb_info *cifs_sb;
2077         struct tcon_link *tlink;
2078         struct cifs_tcon *tcon;
2079         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2080         FILE_UNIX_BASIC_INFO *info_buf_target;
2081         unsigned int xid;
2082         int rc, tmprc;
2083
2084         if (flags & ~RENAME_NOREPLACE)
2085                 return -EINVAL;
2086
2087         cifs_sb = CIFS_SB(source_dir->i_sb);
2088         tlink = cifs_sb_tlink(cifs_sb);
2089         if (IS_ERR(tlink))
2090                 return PTR_ERR(tlink);
2091         tcon = tlink_tcon(tlink);
2092
2093         xid = get_xid();
2094
2095         /*
2096          * we already have the rename sem so we do not need to
2097          * grab it again here to protect the path integrity
2098          */
2099         from_name = build_path_from_dentry(source_dentry);
2100         if (from_name == NULL) {
2101                 rc = -ENOMEM;
2102                 goto cifs_rename_exit;
2103         }
2104
2105         to_name = build_path_from_dentry(target_dentry);
2106         if (to_name == NULL) {
2107                 rc = -ENOMEM;
2108                 goto cifs_rename_exit;
2109         }
2110
2111         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2112                             to_name);
2113
2114         /*
2115          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2116          */
2117         if (flags & RENAME_NOREPLACE)
2118                 goto cifs_rename_exit;
2119
2120         if (rc == -EEXIST && tcon->unix_ext) {
2121                 /*
2122                  * Are src and dst hardlinks of same inode? We can only tell
2123                  * with unix extensions enabled.
2124                  */
2125                 info_buf_source =
2126                         kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2127                                         GFP_KERNEL);
2128                 if (info_buf_source == NULL) {
2129                         rc = -ENOMEM;
2130                         goto cifs_rename_exit;
2131                 }
2132
2133                 info_buf_target = info_buf_source + 1;
2134                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2135                                              info_buf_source,
2136                                              cifs_sb->local_nls,
2137                                              cifs_remap(cifs_sb));
2138                 if (tmprc != 0)
2139                         goto unlink_target;
2140
2141                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2142                                              info_buf_target,
2143                                              cifs_sb->local_nls,
2144                                              cifs_remap(cifs_sb));
2145
2146                 if (tmprc == 0 && (info_buf_source->UniqueId ==
2147                                    info_buf_target->UniqueId)) {
2148                         /* same file, POSIX says that this is a noop */
2149                         rc = 0;
2150                         goto cifs_rename_exit;
2151                 }
2152         }
2153         /*
2154          * else ... BB we could add the same check for Windows by
2155          * checking the UniqueId via FILE_INTERNAL_INFO
2156          */
2157
2158 unlink_target:
2159         /* Try unlinking the target dentry if it's not negative */
2160         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2161                 if (d_is_dir(target_dentry))
2162                         tmprc = cifs_rmdir(target_dir, target_dentry);
2163                 else
2164                         tmprc = cifs_unlink(target_dir, target_dentry);
2165                 if (tmprc)
2166                         goto cifs_rename_exit;
2167                 rc = cifs_do_rename(xid, source_dentry, from_name,
2168                                     target_dentry, to_name);
2169         }
2170
2171         /* force revalidate to go get info when needed */
2172         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2173
2174         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2175                 target_dir->i_mtime = current_time(source_dir);
2176
2177 cifs_rename_exit:
2178         kfree(info_buf_source);
2179         kfree(from_name);
2180         kfree(to_name);
2181         free_xid(xid);
2182         cifs_put_tlink(tlink);
2183         return rc;
2184 }
2185
2186 static bool
2187 cifs_inode_needs_reval(struct inode *inode)
2188 {
2189         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2190         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2191
2192         if (cifs_i->time == 0)
2193                 return true;
2194
2195         if (CIFS_CACHE_READ(cifs_i))
2196                 return false;
2197
2198         if (!lookupCacheEnabled)
2199                 return true;
2200
2201         if (!cifs_sb->ctx->actimeo)
2202                 return true;
2203
2204         if (!time_in_range(jiffies, cifs_i->time,
2205                                 cifs_i->time + cifs_sb->ctx->actimeo))
2206                 return true;
2207
2208         /* hardlinked files w/ noserverino get "special" treatment */
2209         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2210             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2211                 return true;
2212
2213         return false;
2214 }
2215
2216 /*
2217  * Zap the cache. Called when invalid_mapping flag is set.
2218  */
2219 int
2220 cifs_invalidate_mapping(struct inode *inode)
2221 {
2222         int rc = 0;
2223
2224         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2225                 rc = invalidate_inode_pages2(inode->i_mapping);
2226                 if (rc)
2227                         cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2228                                  __func__, inode);
2229         }
2230
2231         cifs_fscache_reset_inode_cookie(inode);
2232         return rc;
2233 }
2234
2235 /**
2236  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2237  *
2238  * @key:        currently unused
2239  * @mode:       the task state to sleep in
2240  */
2241 static int
2242 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2243 {
2244         freezable_schedule_unsafe();
2245         if (signal_pending_state(mode, current))
2246                 return -ERESTARTSYS;
2247         return 0;
2248 }
2249
2250 int
2251 cifs_revalidate_mapping(struct inode *inode)
2252 {
2253         int rc;
2254         unsigned long *flags = &CIFS_I(inode)->flags;
2255
2256         /* swapfiles are not supposed to be shared */
2257         if (IS_SWAPFILE(inode))
2258                 return 0;
2259
2260         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2261                                      TASK_KILLABLE);
2262         if (rc)
2263                 return rc;
2264
2265         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2266                 rc = cifs_invalidate_mapping(inode);
2267                 if (rc)
2268                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
2269         }
2270
2271         clear_bit_unlock(CIFS_INO_LOCK, flags);
2272         smp_mb__after_atomic();
2273         wake_up_bit(flags, CIFS_INO_LOCK);
2274
2275         return rc;
2276 }
2277
2278 int
2279 cifs_zap_mapping(struct inode *inode)
2280 {
2281         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2282         return cifs_revalidate_mapping(inode);
2283 }
2284
2285 int cifs_revalidate_file_attr(struct file *filp)
2286 {
2287         int rc = 0;
2288         struct inode *inode = file_inode(filp);
2289         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2290
2291         if (!cifs_inode_needs_reval(inode))
2292                 return rc;
2293
2294         if (tlink_tcon(cfile->tlink)->unix_ext)
2295                 rc = cifs_get_file_info_unix(filp);
2296         else
2297                 rc = cifs_get_file_info(filp);
2298
2299         return rc;
2300 }
2301
2302 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2303 {
2304         unsigned int xid;
2305         int rc = 0;
2306         struct inode *inode = d_inode(dentry);
2307         struct super_block *sb = dentry->d_sb;
2308         char *full_path = NULL;
2309         int count = 0;
2310
2311         if (inode == NULL)
2312                 return -ENOENT;
2313
2314         if (!cifs_inode_needs_reval(inode))
2315                 return rc;
2316
2317         xid = get_xid();
2318
2319         /* can not safely grab the rename sem here if rename calls revalidate
2320            since that would deadlock */
2321         full_path = build_path_from_dentry(dentry);
2322         if (full_path == NULL) {
2323                 rc = -ENOMEM;
2324                 goto out;
2325         }
2326
2327         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2328                  full_path, inode, inode->i_count.counter,
2329                  dentry, cifs_get_time(dentry), jiffies);
2330
2331 again:
2332         if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2333                 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2334         else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2335                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2336         else
2337                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2338                                          xid, NULL);
2339         if (rc == -EAGAIN && count++ < 10)
2340                 goto again;
2341 out:
2342         kfree(full_path);
2343         free_xid(xid);
2344
2345         return rc;
2346 }
2347
2348 int cifs_revalidate_file(struct file *filp)
2349 {
2350         int rc;
2351         struct inode *inode = file_inode(filp);
2352
2353         rc = cifs_revalidate_file_attr(filp);
2354         if (rc)
2355                 return rc;
2356
2357         return cifs_revalidate_mapping(inode);
2358 }
2359
2360 /* revalidate a dentry's inode attributes */
2361 int cifs_revalidate_dentry(struct dentry *dentry)
2362 {
2363         int rc;
2364         struct inode *inode = d_inode(dentry);
2365
2366         rc = cifs_revalidate_dentry_attr(dentry);
2367         if (rc)
2368                 return rc;
2369
2370         return cifs_revalidate_mapping(inode);
2371 }
2372
2373 int cifs_getattr(const struct path *path, struct kstat *stat,
2374                  u32 request_mask, unsigned int flags)
2375 {
2376         struct dentry *dentry = path->dentry;
2377         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2378         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2379         struct inode *inode = d_inode(dentry);
2380         int rc;
2381
2382         /*
2383          * We need to be sure that all dirty pages are written and the server
2384          * has actual ctime, mtime and file length.
2385          */
2386         if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
2387             !CIFS_CACHE_READ(CIFS_I(inode)) &&
2388             inode->i_mapping && inode->i_mapping->nrpages != 0) {
2389                 rc = filemap_fdatawait(inode->i_mapping);
2390                 if (rc) {
2391                         mapping_set_error(inode->i_mapping, rc);
2392                         return rc;
2393                 }
2394         }
2395
2396         if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2397                 CIFS_I(inode)->time = 0; /* force revalidate */
2398
2399         /*
2400          * If the caller doesn't require syncing, only sync if
2401          * necessary (e.g. due to earlier truncate or setattr
2402          * invalidating the cached metadata)
2403          */
2404         if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2405             (CIFS_I(inode)->time == 0)) {
2406                 rc = cifs_revalidate_dentry_attr(dentry);
2407                 if (rc)
2408                         return rc;
2409         }
2410
2411         generic_fillattr(inode, stat);
2412         stat->blksize = cifs_sb->ctx->bsize;
2413         stat->ino = CIFS_I(inode)->uniqueid;
2414
2415         /* old CIFS Unix Extensions doesn't return create time */
2416         if (CIFS_I(inode)->createtime) {
2417                 stat->result_mask |= STATX_BTIME;
2418                 stat->btime =
2419                       cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2420         }
2421
2422         stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2423         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2424                 stat->attributes |= STATX_ATTR_COMPRESSED;
2425         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2426                 stat->attributes |= STATX_ATTR_ENCRYPTED;
2427
2428         /*
2429          * If on a multiuser mount without unix extensions or cifsacl being
2430          * enabled, and the admin hasn't overridden them, set the ownership
2431          * to the fsuid/fsgid of the current process.
2432          */
2433         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2434             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2435             !tcon->unix_ext) {
2436                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2437                         stat->uid = current_fsuid();
2438                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2439                         stat->gid = current_fsgid();
2440         }
2441         return 0;
2442 }
2443
2444 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2445                 u64 len)
2446 {
2447         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2448         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2449         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2450         struct TCP_Server_Info *server = tcon->ses->server;
2451         struct cifsFileInfo *cfile;
2452         int rc;
2453
2454         /*
2455          * We need to be sure that all dirty pages are written as they
2456          * might fill holes on the server.
2457          */
2458         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2459             inode->i_mapping->nrpages != 0) {
2460                 rc = filemap_fdatawait(inode->i_mapping);
2461                 if (rc) {
2462                         mapping_set_error(inode->i_mapping, rc);
2463                         return rc;
2464                 }
2465         }
2466
2467         cfile = find_readable_file(cifs_i, false);
2468         if (cfile == NULL)
2469                 return -EINVAL;
2470
2471         if (server->ops->fiemap) {
2472                 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2473                 cifsFileInfo_put(cfile);
2474                 return rc;
2475         }
2476
2477         cifsFileInfo_put(cfile);
2478         return -ENOTSUPP;
2479 }
2480
2481 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2482 {
2483         pgoff_t index = from >> PAGE_SHIFT;
2484         unsigned offset = from & (PAGE_SIZE - 1);
2485         struct page *page;
2486         int rc = 0;
2487
2488         page = grab_cache_page(mapping, index);
2489         if (!page)
2490                 return -ENOMEM;
2491
2492         zero_user_segment(page, offset, PAGE_SIZE);
2493         unlock_page(page);
2494         put_page(page);
2495         return rc;
2496 }
2497
2498 void cifs_setsize(struct inode *inode, loff_t offset)
2499 {
2500         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2501
2502         spin_lock(&inode->i_lock);
2503         i_size_write(inode, offset);
2504         spin_unlock(&inode->i_lock);
2505
2506         /* Cached inode must be refreshed on truncate */
2507         cifs_i->time = 0;
2508         truncate_pagecache(inode, offset);
2509 }
2510
2511 static int
2512 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2513                    unsigned int xid, char *full_path)
2514 {
2515         int rc;
2516         struct cifsFileInfo *open_file;
2517         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2518         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2519         struct tcon_link *tlink = NULL;
2520         struct cifs_tcon *tcon = NULL;
2521         struct TCP_Server_Info *server;
2522
2523         /*
2524          * To avoid spurious oplock breaks from server, in the case of
2525          * inodes that we already have open, avoid doing path based
2526          * setting of file size if we can do it by handle.
2527          * This keeps our caching token (oplock) and avoids timeouts
2528          * when the local oplock break takes longer to flush
2529          * writebehind data than the SMB timeout for the SetPathInfo
2530          * request would allow
2531          */
2532         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2533         if (open_file) {
2534                 tcon = tlink_tcon(open_file->tlink);
2535                 server = tcon->ses->server;
2536                 if (server->ops->set_file_size)
2537                         rc = server->ops->set_file_size(xid, tcon, open_file,
2538                                                         attrs->ia_size, false);
2539                 else
2540                         rc = -ENOSYS;
2541                 cifsFileInfo_put(open_file);
2542                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2543         } else
2544                 rc = -EINVAL;
2545
2546         if (!rc)
2547                 goto set_size_out;
2548
2549         if (tcon == NULL) {
2550                 tlink = cifs_sb_tlink(cifs_sb);
2551                 if (IS_ERR(tlink))
2552                         return PTR_ERR(tlink);
2553                 tcon = tlink_tcon(tlink);
2554                 server = tcon->ses->server;
2555         }
2556
2557         /*
2558          * Set file size by pathname rather than by handle either because no
2559          * valid, writeable file handle for it was found or because there was
2560          * an error setting it by handle.
2561          */
2562         if (server->ops->set_path_size)
2563                 rc = server->ops->set_path_size(xid, tcon, full_path,
2564                                                 attrs->ia_size, cifs_sb, false);
2565         else
2566                 rc = -ENOSYS;
2567         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2568
2569         if (tlink)
2570                 cifs_put_tlink(tlink);
2571
2572 set_size_out:
2573         if (rc == 0) {
2574                 cifsInode->server_eof = attrs->ia_size;
2575                 cifs_setsize(inode, attrs->ia_size);
2576
2577                 /*
2578                  * The man page of truncate says if the size changed,
2579                  * then the st_ctime and st_mtime fields for the file
2580                  * are updated.
2581                  */
2582                 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2583                 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2584
2585                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2586         }
2587
2588         return rc;
2589 }
2590
2591 static int
2592 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2593 {
2594         int rc;
2595         unsigned int xid;
2596         char *full_path = NULL;
2597         struct inode *inode = d_inode(direntry);
2598         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2599         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2600         struct tcon_link *tlink;
2601         struct cifs_tcon *pTcon;
2602         struct cifs_unix_set_info_args *args = NULL;
2603         struct cifsFileInfo *open_file;
2604
2605         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2606                  direntry, attrs->ia_valid);
2607
2608         xid = get_xid();
2609
2610         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2611                 attrs->ia_valid |= ATTR_FORCE;
2612
2613         rc = setattr_prepare(direntry, attrs);
2614         if (rc < 0)
2615                 goto out;
2616
2617         full_path = build_path_from_dentry(direntry);
2618         if (full_path == NULL) {
2619                 rc = -ENOMEM;
2620                 goto out;
2621         }
2622
2623         /*
2624          * Attempt to flush data before changing attributes. We need to do
2625          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2626          * ownership or mode then we may also need to do this. Here, we take
2627          * the safe way out and just do the flush on all setattr requests. If
2628          * the flush returns error, store it to report later and continue.
2629          *
2630          * BB: This should be smarter. Why bother flushing pages that
2631          * will be truncated anyway? Also, should we error out here if
2632          * the flush returns error?
2633          */
2634         rc = filemap_write_and_wait(inode->i_mapping);
2635         if (is_interrupt_error(rc)) {
2636                 rc = -ERESTARTSYS;
2637                 goto out;
2638         }
2639
2640         mapping_set_error(inode->i_mapping, rc);
2641         rc = 0;
2642
2643         if (attrs->ia_valid & ATTR_SIZE) {
2644                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2645                 if (rc != 0)
2646                         goto out;
2647         }
2648
2649         /* skip mode change if it's just for clearing setuid/setgid */
2650         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2651                 attrs->ia_valid &= ~ATTR_MODE;
2652
2653         args = kmalloc(sizeof(*args), GFP_KERNEL);
2654         if (args == NULL) {
2655                 rc = -ENOMEM;
2656                 goto out;
2657         }
2658
2659         /* set up the struct */
2660         if (attrs->ia_valid & ATTR_MODE)
2661                 args->mode = attrs->ia_mode;
2662         else
2663                 args->mode = NO_CHANGE_64;
2664
2665         if (attrs->ia_valid & ATTR_UID)
2666                 args->uid = attrs->ia_uid;
2667         else
2668                 args->uid = INVALID_UID; /* no change */
2669
2670         if (attrs->ia_valid & ATTR_GID)
2671                 args->gid = attrs->ia_gid;
2672         else
2673                 args->gid = INVALID_GID; /* no change */
2674
2675         if (attrs->ia_valid & ATTR_ATIME)
2676                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2677         else
2678                 args->atime = NO_CHANGE_64;
2679
2680         if (attrs->ia_valid & ATTR_MTIME)
2681                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2682         else
2683                 args->mtime = NO_CHANGE_64;
2684
2685         if (attrs->ia_valid & ATTR_CTIME)
2686                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2687         else
2688                 args->ctime = NO_CHANGE_64;
2689
2690         args->device = 0;
2691         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2692         if (open_file) {
2693                 u16 nfid = open_file->fid.netfid;
2694                 u32 npid = open_file->pid;
2695                 pTcon = tlink_tcon(open_file->tlink);
2696                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2697                 cifsFileInfo_put(open_file);
2698         } else {
2699                 tlink = cifs_sb_tlink(cifs_sb);
2700                 if (IS_ERR(tlink)) {
2701                         rc = PTR_ERR(tlink);
2702                         goto out;
2703                 }
2704                 pTcon = tlink_tcon(tlink);
2705                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2706                                     cifs_sb->local_nls,
2707                                     cifs_remap(cifs_sb));
2708                 cifs_put_tlink(tlink);
2709         }
2710
2711         if (rc)
2712                 goto out;
2713
2714         if ((attrs->ia_valid & ATTR_SIZE) &&
2715             attrs->ia_size != i_size_read(inode))
2716                 truncate_setsize(inode, attrs->ia_size);
2717
2718         setattr_copy(inode, attrs);
2719         mark_inode_dirty(inode);
2720
2721         /* force revalidate when any of these times are set since some
2722            of the fs types (eg ext3, fat) do not have fine enough
2723            time granularity to match protocol, and we do not have a
2724            a way (yet) to query the server fs's time granularity (and
2725            whether it rounds times down).
2726         */
2727         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2728                 cifsInode->time = 0;
2729 out:
2730         kfree(args);
2731         kfree(full_path);
2732         free_xid(xid);
2733         return rc;
2734 }
2735
2736 static int
2737 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2738 {
2739         unsigned int xid;
2740         kuid_t uid = INVALID_UID;
2741         kgid_t gid = INVALID_GID;
2742         struct inode *inode = d_inode(direntry);
2743         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2744         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2745         struct cifsFileInfo *wfile;
2746         struct cifs_tcon *tcon;
2747         char *full_path = NULL;
2748         int rc = -EACCES;
2749         __u32 dosattr = 0;
2750         __u64 mode = NO_CHANGE_64;
2751
2752         xid = get_xid();
2753
2754         cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2755                  direntry, attrs->ia_valid);
2756
2757         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2758                 attrs->ia_valid |= ATTR_FORCE;
2759
2760         rc = setattr_prepare(direntry, attrs);
2761         if (rc < 0) {
2762                 free_xid(xid);
2763                 return rc;
2764         }
2765
2766         full_path = build_path_from_dentry(direntry);
2767         if (full_path == NULL) {
2768                 rc = -ENOMEM;
2769                 free_xid(xid);
2770                 return rc;
2771         }
2772
2773         /*
2774          * Attempt to flush data before changing attributes. We need to do
2775          * this for ATTR_SIZE and ATTR_MTIME.  If the flush of the data
2776          * returns error, store it to report later and continue.
2777          *
2778          * BB: This should be smarter. Why bother flushing pages that
2779          * will be truncated anyway? Also, should we error out here if
2780          * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2781          */
2782         if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2783                 rc = filemap_write_and_wait(inode->i_mapping);
2784                 if (is_interrupt_error(rc)) {
2785                         rc = -ERESTARTSYS;
2786                         goto cifs_setattr_exit;
2787                 }
2788                 mapping_set_error(inode->i_mapping, rc);
2789         }
2790
2791         rc = 0;
2792
2793         if ((attrs->ia_valid & ATTR_MTIME) &&
2794             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2795                 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2796                 if (!rc) {
2797                         tcon = tlink_tcon(wfile->tlink);
2798                         rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2799                         cifsFileInfo_put(wfile);
2800                         if (rc)
2801                                 goto cifs_setattr_exit;
2802                 } else if (rc != -EBADF)
2803                         goto cifs_setattr_exit;
2804                 else
2805                         rc = 0;
2806         }
2807
2808         if (attrs->ia_valid & ATTR_SIZE) {
2809                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2810                 if (rc != 0)
2811                         goto cifs_setattr_exit;
2812         }
2813
2814         if (attrs->ia_valid & ATTR_UID)
2815                 uid = attrs->ia_uid;
2816
2817         if (attrs->ia_valid & ATTR_GID)
2818                 gid = attrs->ia_gid;
2819
2820         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2821             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2822                 if (uid_valid(uid) || gid_valid(gid)) {
2823                         mode = NO_CHANGE_64;
2824                         rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2825                                                         uid, gid);
2826                         if (rc) {
2827                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2828                                          __func__, rc);
2829                                 goto cifs_setattr_exit;
2830                         }
2831                 }
2832         } else
2833         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2834                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2835
2836         /* skip mode change if it's just for clearing setuid/setgid */
2837         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2838                 attrs->ia_valid &= ~ATTR_MODE;
2839
2840         if (attrs->ia_valid & ATTR_MODE) {
2841                 mode = attrs->ia_mode;
2842                 rc = 0;
2843                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2844                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2845                         rc = id_mode_to_cifs_acl(inode, full_path, &mode,
2846                                                 INVALID_UID, INVALID_GID);
2847                         if (rc) {
2848                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2849                                          __func__, rc);
2850                                 goto cifs_setattr_exit;
2851                         }
2852
2853                         /*
2854                          * In case of CIFS_MOUNT_CIFS_ACL, we cannot support all modes.
2855                          * Pick up the actual mode bits that were set.
2856                          */
2857                         if (mode != attrs->ia_mode)
2858                                 attrs->ia_mode = mode;
2859                 } else
2860                 if (((mode & S_IWUGO) == 0) &&
2861                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2862
2863                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2864
2865                         /* fix up mode if we're not using dynperm */
2866                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2867                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2868                 } else if ((mode & S_IWUGO) &&
2869                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2870
2871                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2872                         /* Attributes of 0 are ignored */
2873                         if (dosattr == 0)
2874                                 dosattr |= ATTR_NORMAL;
2875
2876                         /* reset local inode permissions to normal */
2877                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2878                                 attrs->ia_mode &= ~(S_IALLUGO);
2879                                 if (S_ISDIR(inode->i_mode))
2880                                         attrs->ia_mode |=
2881                                                 cifs_sb->ctx->dir_mode;
2882                                 else
2883                                         attrs->ia_mode |=
2884                                                 cifs_sb->ctx->file_mode;
2885                         }
2886                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2887                         /* ignore mode change - ATTR_READONLY hasn't changed */
2888                         attrs->ia_valid &= ~ATTR_MODE;
2889                 }
2890         }
2891
2892         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2893             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2894                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2895                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2896
2897                 /* Even if error on time set, no sense failing the call if
2898                 the server would set the time to a reasonable value anyway,
2899                 and this check ensures that we are not being called from
2900                 sys_utimes in which case we ought to fail the call back to
2901                 the user when the server rejects the call */
2902                 if ((rc) && (attrs->ia_valid &
2903                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2904                         rc = 0;
2905         }
2906
2907         /* do not need local check to inode_check_ok since the server does
2908            that */
2909         if (rc)
2910                 goto cifs_setattr_exit;
2911
2912         if ((attrs->ia_valid & ATTR_SIZE) &&
2913             attrs->ia_size != i_size_read(inode))
2914                 truncate_setsize(inode, attrs->ia_size);
2915
2916         setattr_copy(inode, attrs);
2917         mark_inode_dirty(inode);
2918
2919 cifs_setattr_exit:
2920         kfree(full_path);
2921         free_xid(xid);
2922         return rc;
2923 }
2924
2925 int
2926 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2927 {
2928         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2929         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2930         int rc, retries = 0;
2931
2932         do {
2933                 if (pTcon->unix_ext)
2934                         rc = cifs_setattr_unix(direntry, attrs);
2935                 else
2936                         rc = cifs_setattr_nounix(direntry, attrs);
2937                 retries++;
2938         } while (is_retryable_error(rc) && retries < 2);
2939
2940         /* BB: add cifs_setattr_legacy for really old servers */
2941         return rc;
2942 }
2943
2944 #if 0
2945 void cifs_delete_inode(struct inode *inode)
2946 {
2947         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2948         /* may have to add back in if and when safe distributed caching of
2949            directories added e.g. via FindNotify */
2950 }
2951 #endif