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