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