fs/cifs/inode.c

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