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