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