fs/cifs/inode.c

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