fs/cifs/inode.c

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