fs/cifs/inode.c

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