fs/cifs/inode.c

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