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