fs/cifs/inode.c

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