fs/cifs/inode.c

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