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_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                         if (S_ISREG(inode->i_mode))
 941                                 inode->i_data.backing_dev_info = sb->s_bdi;
 942 #ifdef CONFIG_CIFS_FSCACHE
 943                         /* initialize per-inode cache cookie pointer */
 944                         CIFS_I(inode)->fscache = NULL;
 945 #endif
 946                         unlock_new_inode(inode);
 947                 }
 948         }
 949
 950         return inode;
 951 }
 952
 953 /* gets root inode */
 954 struct inode *cifs_root_iget(struct super_block *sb)
 955 {
 956         unsigned int xid;
 957         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 958         struct inode *inode = NULL;
 959         long rc;
 960         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
 961
 962         xid = get_xid();
 963         if (tcon->unix_ext) {
 964                 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
 965                 /* some servers mistakenly claim POSIX support */
 966                 if (rc != -EOPNOTSUPP)
 967                         goto iget_no_retry;
 968                 cifs_dbg(VFS, "server does not support POSIX extensions");
 969                 tcon->unix_ext = false;
 970         }
 971
 972         rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
 973
 974 iget_no_retry:
 975         if (!inode) {
 976                 inode = ERR_PTR(rc);
 977                 goto out;
 978         }
 979
 980 #ifdef CONFIG_CIFS_FSCACHE
 981         /* populate tcon->resource_id */
 982         tcon->resource_id = CIFS_I(inode)->uniqueid;
 983 #endif
 984
 985         if (rc && tcon->ipc) {
 986                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
 987                 spin_lock(&inode->i_lock);
 988                 inode->i_mode |= S_IFDIR;
 989                 set_nlink(inode, 2);
 990                 inode->i_op = &cifs_ipc_inode_ops;
 991                 inode->i_fop = &simple_dir_operations;
 992                 inode->i_uid = cifs_sb->mnt_uid;
 993                 inode->i_gid = cifs_sb->mnt_gid;
 994                 spin_unlock(&inode->i_lock);
 995         } else if (rc) {
 996                 iget_failed(inode);
 997                 inode = ERR_PTR(rc);
 998         }
 999
1000 out:
1001         /* can not call macro free_xid here since in a void func
1002          * TODO: This is no longer true
1003          */
1004         _free_xid(xid);
1005         return inode;
1006 }
1007
1008 int
1009 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1010                    char *full_path, __u32 dosattr)
1011 {
1012         bool set_time = false;
1013         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1014         struct TCP_Server_Info *server;
1015         FILE_BASIC_INFO info_buf;
1016
1017         if (attrs == NULL)
1018                 return -EINVAL;
1019
1020         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1021         if (!server->ops->set_file_info)
1022                 return -ENOSYS;
1023
1024         if (attrs->ia_valid & ATTR_ATIME) {
1025                 set_time = true;
1026                 info_buf.LastAccessTime =
1027                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1028         } else
1029                 info_buf.LastAccessTime = 0;
1030
1031         if (attrs->ia_valid & ATTR_MTIME) {
1032                 set_time = true;
1033                 info_buf.LastWriteTime =
1034                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1035         } else
1036                 info_buf.LastWriteTime = 0;
1037
1038         /*
1039          * Samba throws this field away, but windows may actually use it.
1040          * Do not set ctime unless other time stamps are changed explicitly
1041          * (i.e. by utimes()) since we would then have a mix of client and
1042          * server times.
1043          */
1044         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1045                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1046                 info_buf.ChangeTime =
1047                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1048         } else
1049                 info_buf.ChangeTime = 0;
1050
1051         info_buf.CreationTime = 0;      /* don't change */
1052         info_buf.Attributes = cpu_to_le32(dosattr);
1053
1054         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1055 }
1056
1057 /*
1058  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1059  * and rename it to a random name that hopefully won't conflict with
1060  * anything else.
1061  */
1062 int
1063 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1064                            const unsigned int xid)
1065 {
1066         int oplock = 0;
1067         int rc;
1068         struct cifs_fid fid;
1069         struct cifs_open_parms oparms;
1070         struct inode *inode = dentry->d_inode;
1071         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1072         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1073         struct tcon_link *tlink;
1074         struct cifs_tcon *tcon;
1075         __u32 dosattr, origattr;
1076         FILE_BASIC_INFO *info_buf = NULL;
1077
1078         tlink = cifs_sb_tlink(cifs_sb);
1079         if (IS_ERR(tlink))
1080                 return PTR_ERR(tlink);
1081         tcon = tlink_tcon(tlink);
1082
1083         /*
1084          * We cannot rename the file if the server doesn't support
1085          * CAP_INFOLEVEL_PASSTHRU
1086          */
1087         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1088                 rc = -EBUSY;
1089                 goto out;
1090         }
1091
1092         oparms.tcon = tcon;
1093         oparms.cifs_sb = cifs_sb;
1094         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1095         oparms.create_options = CREATE_NOT_DIR;
1096         oparms.disposition = FILE_OPEN;
1097         oparms.path = full_path;
1098         oparms.fid = &fid;
1099         oparms.reconnect = false;
1100
1101         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1102         if (rc != 0)
1103                 goto out;
1104
1105         origattr = cifsInode->cifsAttrs;
1106         if (origattr == 0)
1107                 origattr |= ATTR_NORMAL;
1108
1109         dosattr = origattr & ~ATTR_READONLY;
1110         if (dosattr == 0)
1111                 dosattr |= ATTR_NORMAL;
1112         dosattr |= ATTR_HIDDEN;
1113
1114         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1115         if (dosattr != origattr) {
1116                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1117                 if (info_buf == NULL) {
1118                         rc = -ENOMEM;
1119                         goto out_close;
1120                 }
1121                 info_buf->Attributes = cpu_to_le32(dosattr);
1122                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1123                                         current->tgid);
1124                 /* although we would like to mark the file hidden
1125                    if that fails we will still try to rename it */
1126                 if (!rc)
1127                         cifsInode->cifsAttrs = dosattr;
1128                 else
1129                         dosattr = origattr; /* since not able to change them */
1130         }
1131
1132         /* rename the file */
1133         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1134                                    cifs_sb->local_nls,
1135                                    cifs_remap(cifs_sb));
1136         if (rc != 0) {
1137                 rc = -EBUSY;
1138                 goto undo_setattr;
1139         }
1140
1141         /* try to set DELETE_ON_CLOSE */
1142         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1143                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1144                                                current->tgid);
1145                 /*
1146                  * some samba versions return -ENOENT when we try to set the
1147                  * file disposition here. Likely a samba bug, but work around
1148                  * it for now. This means that some cifsXXX files may hang
1149                  * around after they shouldn't.
1150                  *
1151                  * BB: remove this hack after more servers have the fix
1152                  */
1153                 if (rc == -ENOENT)
1154                         rc = 0;
1155                 else if (rc != 0) {
1156                         rc = -EBUSY;
1157                         goto undo_rename;
1158                 }
1159                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1160         }
1161
1162 out_close:
1163         CIFSSMBClose(xid, tcon, fid.netfid);
1164 out:
1165         kfree(info_buf);
1166         cifs_put_tlink(tlink);
1167         return rc;
1168
1169         /*
1170          * reset everything back to the original state. Don't bother
1171          * dealing with errors here since we can't do anything about
1172          * them anyway.
1173          */
1174 undo_rename:
1175         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1176                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1177 undo_setattr:
1178         if (dosattr != origattr) {
1179                 info_buf->Attributes = cpu_to_le32(origattr);
1180                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1181                                         current->tgid))
1182                         cifsInode->cifsAttrs = origattr;
1183         }
1184
1185         goto out_close;
1186 }
1187
1188 /* copied from fs/nfs/dir.c with small changes */
1189 static void
1190 cifs_drop_nlink(struct inode *inode)
1191 {
1192         spin_lock(&inode->i_lock);
1193         if (inode->i_nlink > 0)
1194                 drop_nlink(inode);
1195         spin_unlock(&inode->i_lock);
1196 }
1197
1198 /*
1199  * If dentry->d_inode is null (usually meaning the cached dentry
1200  * is a negative dentry) then we would attempt a standard SMB delete, but
1201  * if that fails we can not attempt the fall back mechanisms on EACCESS
1202  * but will return the EACCESS to the caller. Note that the VFS does not call
1203  * unlink on negative dentries currently.
1204  */
1205 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1206 {
1207         int rc = 0;
1208         unsigned int xid;
1209         char *full_path = NULL;
1210         struct inode *inode = dentry->d_inode;
1211         struct cifsInodeInfo *cifs_inode;
1212         struct super_block *sb = dir->i_sb;
1213         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1214         struct tcon_link *tlink;
1215         struct cifs_tcon *tcon;
1216         struct TCP_Server_Info *server;
1217         struct iattr *attrs = NULL;
1218         __u32 dosattr = 0, origattr = 0;
1219
1220         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1221
1222         tlink = cifs_sb_tlink(cifs_sb);
1223         if (IS_ERR(tlink))
1224                 return PTR_ERR(tlink);
1225         tcon = tlink_tcon(tlink);
1226         server = tcon->ses->server;
1227
1228         xid = get_xid();
1229
1230         /* Unlink can be called from rename so we can not take the
1231          * sb->s_vfs_rename_mutex here */
1232         full_path = build_path_from_dentry(dentry);
1233         if (full_path == NULL) {
1234                 rc = -ENOMEM;
1235                 goto unlink_out;
1236         }
1237
1238         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1239                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1240                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1241                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1242                         cifs_remap(cifs_sb));
1243                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1244                 if ((rc == 0) || (rc == -ENOENT))
1245                         goto psx_del_no_retry;
1246         }
1247
1248 retry_std_delete:
1249         if (!server->ops->unlink) {
1250                 rc = -ENOSYS;
1251                 goto psx_del_no_retry;
1252         }
1253
1254         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1255
1256 psx_del_no_retry:
1257         if (!rc) {
1258                 if (inode)
1259                         cifs_drop_nlink(inode);
1260         } else if (rc == -ENOENT) {
1261                 d_drop(dentry);
1262         } else if (rc == -EBUSY) {
1263                 if (server->ops->rename_pending_delete) {
1264                         rc = server->ops->rename_pending_delete(full_path,
1265                                                                 dentry, xid);
1266                         if (rc == 0)
1267                                 cifs_drop_nlink(inode);
1268                 }
1269         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1270                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1271                 if (attrs == NULL) {
1272                         rc = -ENOMEM;
1273                         goto out_reval;
1274                 }
1275
1276                 /* try to reset dos attributes */
1277                 cifs_inode = CIFS_I(inode);
1278                 origattr = cifs_inode->cifsAttrs;
1279                 if (origattr == 0)
1280                         origattr |= ATTR_NORMAL;
1281                 dosattr = origattr & ~ATTR_READONLY;
1282                 if (dosattr == 0)
1283                         dosattr |= ATTR_NORMAL;
1284                 dosattr |= ATTR_HIDDEN;
1285
1286                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1287                 if (rc != 0)
1288                         goto out_reval;
1289
1290                 goto retry_std_delete;
1291         }
1292
1293         /* undo the setattr if we errored out and it's needed */
1294         if (rc != 0 && dosattr != 0)
1295                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1296
1297 out_reval:
1298         if (inode) {
1299                 cifs_inode = CIFS_I(inode);
1300                 cifs_inode->time = 0;   /* will force revalidate to get info
1301                                            when needed */
1302                 inode->i_ctime = current_fs_time(sb);
1303         }
1304         dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1305         cifs_inode = CIFS_I(dir);
1306         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1307 unlink_out:
1308         kfree(full_path);
1309         kfree(attrs);
1310         free_xid(xid);
1311         cifs_put_tlink(tlink);
1312         return rc;
1313 }
1314
1315 static int
1316 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1317                  const char *full_path, struct cifs_sb_info *cifs_sb,
1318                  struct cifs_tcon *tcon, const unsigned int xid)
1319 {
1320         int rc = 0;
1321         struct inode *inode = NULL;
1322
1323         if (tcon->unix_ext)
1324                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1325                                               xid);
1326         else
1327                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1328                                          xid, NULL);
1329
1330         if (rc)
1331                 return rc;
1332
1333         /*
1334          * setting nlink not necessary except in cases where we failed to get it
1335          * from the server or was set bogus. Also, since this is a brand new
1336          * inode, no need to grab the i_lock before setting the i_nlink.
1337          */
1338         if (inode->i_nlink < 2)
1339                 set_nlink(inode, 2);
1340         mode &= ~current_umask();
1341         /* must turn on setgid bit if parent dir has it */
1342         if (parent->i_mode & S_ISGID)
1343                 mode |= S_ISGID;
1344
1345         if (tcon->unix_ext) {
1346                 struct cifs_unix_set_info_args args = {
1347                         .mode   = mode,
1348                         .ctime  = NO_CHANGE_64,
1349                         .atime  = NO_CHANGE_64,
1350                         .mtime  = NO_CHANGE_64,
1351                         .device = 0,
1352                 };
1353                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1354                         args.uid = current_fsuid();
1355                         if (parent->i_mode & S_ISGID)
1356                                 args.gid = parent->i_gid;
1357                         else
1358                                 args.gid = current_fsgid();
1359                 } else {
1360                         args.uid = INVALID_UID; /* no change */
1361                         args.gid = INVALID_GID; /* no change */
1362                 }
1363                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1364                                        cifs_sb->local_nls,
1365                                        cifs_remap(cifs_sb));
1366         } else {
1367                 struct TCP_Server_Info *server = tcon->ses->server;
1368                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1369                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1370                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1371                                                    tcon, xid);
1372                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1373                         inode->i_mode = (mode | S_IFDIR);
1374
1375                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1376                         inode->i_uid = current_fsuid();
1377                         if (inode->i_mode & S_ISGID)
1378                                 inode->i_gid = parent->i_gid;
1379                         else
1380                                 inode->i_gid = current_fsgid();
1381                 }
1382         }
1383         d_instantiate(dentry, inode);
1384         return rc;
1385 }
1386
1387 static int
1388 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1389                  const char *full_path, struct cifs_sb_info *cifs_sb,
1390                  struct cifs_tcon *tcon, const unsigned int xid)
1391 {
1392         int rc = 0;
1393         u32 oplock = 0;
1394         FILE_UNIX_BASIC_INFO *info = NULL;
1395         struct inode *newinode = NULL;
1396         struct cifs_fattr fattr;
1397
1398         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1399         if (info == NULL) {
1400                 rc = -ENOMEM;
1401                 goto posix_mkdir_out;
1402         }
1403
1404         mode &= ~current_umask();
1405         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1406                              NULL /* netfid */, info, &oplock, full_path,
1407                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1408         if (rc == -EOPNOTSUPP)
1409                 goto posix_mkdir_out;
1410         else if (rc) {
1411                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1412                 d_drop(dentry);
1413                 goto posix_mkdir_out;
1414         }
1415
1416         if (info->Type == cpu_to_le32(-1))
1417                 /* no return info, go query for it */
1418                 goto posix_mkdir_get_info;
1419         /*
1420          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1421          * need to set uid/gid.
1422          */
1423
1424         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1425         cifs_fill_uniqueid(inode->i_sb, &fattr);
1426         newinode = cifs_iget(inode->i_sb, &fattr);
1427         if (!newinode)
1428                 goto posix_mkdir_get_info;
1429
1430         d_instantiate(dentry, newinode);
1431
1432 #ifdef CONFIG_CIFS_DEBUG2
1433         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1434                  dentry, dentry, newinode);
1435
1436         if (newinode->i_nlink != 2)
1437                 cifs_dbg(FYI, "unexpected number of links %d\n",
1438                          newinode->i_nlink);
1439 #endif
1440
1441 posix_mkdir_out:
1442         kfree(info);
1443         return rc;
1444 posix_mkdir_get_info:
1445         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1446                               xid);
1447         goto posix_mkdir_out;
1448 }
1449
1450 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1451 {
1452         int rc = 0;
1453         unsigned int xid;
1454         struct cifs_sb_info *cifs_sb;
1455         struct tcon_link *tlink;
1456         struct cifs_tcon *tcon;
1457         struct TCP_Server_Info *server;
1458         char *full_path;
1459
1460         cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1461                  mode, inode);
1462
1463         cifs_sb = CIFS_SB(inode->i_sb);
1464         tlink = cifs_sb_tlink(cifs_sb);
1465         if (IS_ERR(tlink))
1466                 return PTR_ERR(tlink);
1467         tcon = tlink_tcon(tlink);
1468
1469         xid = get_xid();
1470
1471         full_path = build_path_from_dentry(direntry);
1472         if (full_path == NULL) {
1473                 rc = -ENOMEM;
1474                 goto mkdir_out;
1475         }
1476
1477         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1478                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1479                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1480                                       tcon, xid);
1481                 if (rc != -EOPNOTSUPP)
1482                         goto mkdir_out;
1483         }
1484
1485         server = tcon->ses->server;
1486
1487         if (!server->ops->mkdir) {
1488                 rc = -ENOSYS;
1489                 goto mkdir_out;
1490         }
1491
1492         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1493         rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1494         if (rc) {
1495                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1496                 d_drop(direntry);
1497                 goto mkdir_out;
1498         }
1499
1500         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1501                               xid);
1502 mkdir_out:
1503         /*
1504          * Force revalidate to get parent dir info when needed since cached
1505          * attributes are invalid now.
1506          */
1507         CIFS_I(inode)->time = 0;
1508         kfree(full_path);
1509         free_xid(xid);
1510         cifs_put_tlink(tlink);
1511         return rc;
1512 }
1513
1514 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1515 {
1516         int rc = 0;
1517         unsigned int xid;
1518         struct cifs_sb_info *cifs_sb;
1519         struct tcon_link *tlink;
1520         struct cifs_tcon *tcon;
1521         struct TCP_Server_Info *server;
1522         char *full_path = NULL;
1523         struct cifsInodeInfo *cifsInode;
1524
1525         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1526
1527         xid = get_xid();
1528
1529         full_path = build_path_from_dentry(direntry);
1530         if (full_path == NULL) {
1531                 rc = -ENOMEM;
1532                 goto rmdir_exit;
1533         }
1534
1535         cifs_sb = CIFS_SB(inode->i_sb);
1536         tlink = cifs_sb_tlink(cifs_sb);
1537         if (IS_ERR(tlink)) {
1538                 rc = PTR_ERR(tlink);
1539                 goto rmdir_exit;
1540         }
1541         tcon = tlink_tcon(tlink);
1542         server = tcon->ses->server;
1543
1544         if (!server->ops->rmdir) {
1545                 rc = -ENOSYS;
1546                 cifs_put_tlink(tlink);
1547                 goto rmdir_exit;
1548         }
1549
1550         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1551         cifs_put_tlink(tlink);
1552
1553         if (!rc) {
1554                 spin_lock(&direntry->d_inode->i_lock);
1555                 i_size_write(direntry->d_inode, 0);
1556                 clear_nlink(direntry->d_inode);
1557                 spin_unlock(&direntry->d_inode->i_lock);
1558         }
1559
1560         cifsInode = CIFS_I(direntry->d_inode);
1561         /* force revalidate to go get info when needed */
1562         cifsInode->time = 0;
1563
1564         cifsInode = CIFS_I(inode);
1565         /*
1566          * Force revalidate to get parent dir info when needed since cached
1567          * attributes are invalid now.
1568          */
1569         cifsInode->time = 0;
1570
1571         direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1572                 current_fs_time(inode->i_sb);
1573
1574 rmdir_exit:
1575         kfree(full_path);
1576         free_xid(xid);
1577         return rc;
1578 }
1579
1580 static int
1581 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1582                const char *from_path, struct dentry *to_dentry,
1583                const char *to_path)
1584 {
1585         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1586         struct tcon_link *tlink;
1587         struct cifs_tcon *tcon;
1588         struct TCP_Server_Info *server;
1589         struct cifs_fid fid;
1590         struct cifs_open_parms oparms;
1591         int oplock, rc;
1592
1593         tlink = cifs_sb_tlink(cifs_sb);
1594         if (IS_ERR(tlink))
1595                 return PTR_ERR(tlink);
1596         tcon = tlink_tcon(tlink);
1597         server = tcon->ses->server;
1598
1599         if (!server->ops->rename)
1600                 return -ENOSYS;
1601
1602         /* try path-based rename first */
1603         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1604
1605         /*
1606          * Don't bother with rename by filehandle unless file is busy and
1607          * source. Note that cross directory moves do not work with
1608          * rename by filehandle to various Windows servers.
1609          */
1610         if (rc == 0 || rc != -EBUSY)
1611                 goto do_rename_exit;
1612
1613         /* open-file renames don't work across directories */
1614         if (to_dentry->d_parent != from_dentry->d_parent)
1615                 goto do_rename_exit;
1616
1617         oparms.tcon = tcon;
1618         oparms.cifs_sb = cifs_sb;
1619         /* open the file to be renamed -- we need DELETE perms */
1620         oparms.desired_access = DELETE;
1621         oparms.create_options = CREATE_NOT_DIR;
1622         oparms.disposition = FILE_OPEN;
1623         oparms.path = from_path;
1624         oparms.fid = &fid;
1625         oparms.reconnect = false;
1626
1627         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1628         if (rc == 0) {
1629                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1630                                 (const char *) to_dentry->d_name.name,
1631                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1632                 CIFSSMBClose(xid, tcon, fid.netfid);
1633         }
1634 do_rename_exit:
1635         cifs_put_tlink(tlink);
1636         return rc;
1637 }
1638
1639 int
1640 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1641              struct inode *target_dir, struct dentry *target_dentry,
1642              unsigned int flags)
1643 {
1644         char *from_name = NULL;
1645         char *to_name = NULL;
1646         struct cifs_sb_info *cifs_sb;
1647         struct tcon_link *tlink;
1648         struct cifs_tcon *tcon;
1649         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1650         FILE_UNIX_BASIC_INFO *info_buf_target;
1651         unsigned int xid;
1652         int rc, tmprc;
1653
1654         if (flags & ~RENAME_NOREPLACE)
1655                 return -EINVAL;
1656
1657         cifs_sb = CIFS_SB(source_dir->i_sb);
1658         tlink = cifs_sb_tlink(cifs_sb);
1659         if (IS_ERR(tlink))
1660                 return PTR_ERR(tlink);
1661         tcon = tlink_tcon(tlink);
1662
1663         xid = get_xid();
1664
1665         /*
1666          * we already have the rename sem so we do not need to
1667          * grab it again here to protect the path integrity
1668          */
1669         from_name = build_path_from_dentry(source_dentry);
1670         if (from_name == NULL) {
1671                 rc = -ENOMEM;
1672                 goto cifs_rename_exit;
1673         }
1674
1675         to_name = build_path_from_dentry(target_dentry);
1676         if (to_name == NULL) {
1677                 rc = -ENOMEM;
1678                 goto cifs_rename_exit;
1679         }
1680
1681         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1682                             to_name);
1683
1684         /*
1685          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1686          */
1687         if (flags & RENAME_NOREPLACE)
1688                 goto cifs_rename_exit;
1689
1690         if (rc == -EEXIST && tcon->unix_ext) {
1691                 /*
1692                  * Are src and dst hardlinks of same inode? We can only tell
1693                  * with unix extensions enabled.
1694                  */
1695                 info_buf_source =
1696                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1697                                         GFP_KERNEL);
1698                 if (info_buf_source == NULL) {
1699                         rc = -ENOMEM;
1700                         goto cifs_rename_exit;
1701                 }
1702
1703                 info_buf_target = info_buf_source + 1;
1704                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1705                                              info_buf_source,
1706                                              cifs_sb->local_nls,
1707                                              cifs_remap(cifs_sb));
1708                 if (tmprc != 0)
1709                         goto unlink_target;
1710
1711                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1712                                              info_buf_target,
1713                                              cifs_sb->local_nls,
1714                                              cifs_remap(cifs_sb));
1715
1716                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1717                                    info_buf_target->UniqueId)) {
1718                         /* same file, POSIX says that this is a noop */
1719                         rc = 0;
1720                         goto cifs_rename_exit;
1721                 }
1722         }
1723         /*
1724          * else ... BB we could add the same check for Windows by
1725          * checking the UniqueId via FILE_INTERNAL_INFO
1726          */
1727
1728 unlink_target:
1729         /* Try unlinking the target dentry if it's not negative */
1730         if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1731                 if (d_is_dir(target_dentry))
1732                         tmprc = cifs_rmdir(target_dir, target_dentry);
1733                 else
1734                         tmprc = cifs_unlink(target_dir, target_dentry);
1735                 if (tmprc)
1736                         goto cifs_rename_exit;
1737                 rc = cifs_do_rename(xid, source_dentry, from_name,
1738                                     target_dentry, to_name);
1739         }
1740
1741         /* force revalidate to go get info when needed */
1742         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1743
1744         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1745                 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1746
1747 cifs_rename_exit:
1748         kfree(info_buf_source);
1749         kfree(from_name);
1750         kfree(to_name);
1751         free_xid(xid);
1752         cifs_put_tlink(tlink);
1753         return rc;
1754 }
1755
1756 static bool
1757 cifs_inode_needs_reval(struct inode *inode)
1758 {
1759         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1760         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1761
1762         if (CIFS_CACHE_READ(cifs_i))
1763                 return false;
1764
1765         if (!lookupCacheEnabled)
1766                 return true;
1767
1768         if (cifs_i->time == 0)
1769                 return true;
1770
1771         if (!cifs_sb->actimeo)
1772                 return true;
1773
1774         if (!time_in_range(jiffies, cifs_i->time,
1775                                 cifs_i->time + cifs_sb->actimeo))
1776                 return true;
1777
1778         /* hardlinked files w/ noserverino get "special" treatment */
1779         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1780             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1781                 return true;
1782
1783         return false;
1784 }
1785
1786 /*
1787  * Zap the cache. Called when invalid_mapping flag is set.
1788  */
1789 int
1790 cifs_invalidate_mapping(struct inode *inode)
1791 {
1792         int rc = 0;
1793
1794         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1795                 rc = invalidate_inode_pages2(inode->i_mapping);
1796                 if (rc)
1797                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1798                                  __func__, inode);
1799         }
1800
1801         cifs_fscache_reset_inode_cookie(inode);
1802         return rc;
1803 }
1804
1805 /**
1806  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1807  * @word: long word containing the bit lock
1808  */
1809 static int
1810 cifs_wait_bit_killable(struct wait_bit_key *key)
1811 {
1812         if (fatal_signal_pending(current))
1813                 return -ERESTARTSYS;
1814         freezable_schedule_unsafe();
1815         return 0;
1816 }
1817
1818 int
1819 cifs_revalidate_mapping(struct inode *inode)
1820 {
1821         int rc;
1822         unsigned long *flags = &CIFS_I(inode)->flags;
1823
1824         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1825                                      TASK_KILLABLE);
1826         if (rc)
1827                 return rc;
1828
1829         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1830                 rc = cifs_invalidate_mapping(inode);
1831                 if (rc)
1832                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1833         }
1834
1835         clear_bit_unlock(CIFS_INO_LOCK, flags);
1836         smp_mb__after_atomic();
1837         wake_up_bit(flags, CIFS_INO_LOCK);
1838
1839         return rc;
1840 }
1841
1842 int
1843 cifs_zap_mapping(struct inode *inode)
1844 {
1845         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1846         return cifs_revalidate_mapping(inode);
1847 }
1848
1849 int cifs_revalidate_file_attr(struct file *filp)
1850 {
1851         int rc = 0;
1852         struct inode *inode = file_inode(filp);
1853         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1854
1855         if (!cifs_inode_needs_reval(inode))
1856                 return rc;
1857
1858         if (tlink_tcon(cfile->tlink)->unix_ext)
1859                 rc = cifs_get_file_info_unix(filp);
1860         else
1861                 rc = cifs_get_file_info(filp);
1862
1863         return rc;
1864 }
1865
1866 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1867 {
1868         unsigned int xid;
1869         int rc = 0;
1870         struct inode *inode = dentry->d_inode;
1871         struct super_block *sb = dentry->d_sb;
1872         char *full_path = NULL;
1873
1874         if (inode == NULL)
1875                 return -ENOENT;
1876
1877         if (!cifs_inode_needs_reval(inode))
1878                 return rc;
1879
1880         xid = get_xid();
1881
1882         /* can not safely grab the rename sem here if rename calls revalidate
1883            since that would deadlock */
1884         full_path = build_path_from_dentry(dentry);
1885         if (full_path == NULL) {
1886                 rc = -ENOMEM;
1887                 goto out;
1888         }
1889
1890         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1891                  full_path, inode, inode->i_count.counter,
1892                  dentry, dentry->d_time, jiffies);
1893
1894         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1895                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1896         else
1897                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1898                                          xid, NULL);
1899
1900 out:
1901         kfree(full_path);
1902         free_xid(xid);
1903         return rc;
1904 }
1905
1906 int cifs_revalidate_file(struct file *filp)
1907 {
1908         int rc;
1909         struct inode *inode = file_inode(filp);
1910
1911         rc = cifs_revalidate_file_attr(filp);
1912         if (rc)
1913                 return rc;
1914
1915         return cifs_revalidate_mapping(inode);
1916 }
1917
1918 /* revalidate a dentry's inode attributes */
1919 int cifs_revalidate_dentry(struct dentry *dentry)
1920 {
1921         int rc;
1922         struct inode *inode = dentry->d_inode;
1923
1924         rc = cifs_revalidate_dentry_attr(dentry);
1925         if (rc)
1926                 return rc;
1927
1928         return cifs_revalidate_mapping(inode);
1929 }
1930
1931 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1932                  struct kstat *stat)
1933 {
1934         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1935         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1936         struct inode *inode = dentry->d_inode;
1937         int rc;
1938
1939         /*
1940          * We need to be sure that all dirty pages are written and the server
1941          * has actual ctime, mtime and file length.
1942          */
1943         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1944             inode->i_mapping->nrpages != 0) {
1945                 rc = filemap_fdatawait(inode->i_mapping);
1946                 if (rc) {
1947                         mapping_set_error(inode->i_mapping, rc);
1948                         return rc;
1949                 }
1950         }
1951
1952         rc = cifs_revalidate_dentry_attr(dentry);
1953         if (rc)
1954                 return rc;
1955
1956         generic_fillattr(inode, stat);
1957         stat->blksize = CIFS_MAX_MSGSIZE;
1958         stat->ino = CIFS_I(inode)->uniqueid;
1959
1960         /*
1961          * If on a multiuser mount without unix extensions or cifsacl being
1962          * enabled, and the admin hasn't overridden them, set the ownership
1963          * to the fsuid/fsgid of the current process.
1964          */
1965         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1966             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1967             !tcon->unix_ext) {
1968                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1969                         stat->uid = current_fsuid();
1970                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1971                         stat->gid = current_fsgid();
1972         }
1973         return rc;
1974 }
1975
1976 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1977 {
1978         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1979         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1980         struct page *page;
1981         int rc = 0;
1982
1983         page = grab_cache_page(mapping, index);
1984         if (!page)
1985                 return -ENOMEM;
1986
1987         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1988         unlock_page(page);
1989         page_cache_release(page);
1990         return rc;
1991 }
1992
1993 static void cifs_setsize(struct inode *inode, loff_t offset)
1994 {
1995         spin_lock(&inode->i_lock);
1996         i_size_write(inode, offset);
1997         spin_unlock(&inode->i_lock);
1998
1999         truncate_pagecache(inode, offset);
2000 }
2001
2002 static int
2003 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2004                    unsigned int xid, char *full_path)
2005 {
2006         int rc;
2007         struct cifsFileInfo *open_file;
2008         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2009         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2010         struct tcon_link *tlink = NULL;
2011         struct cifs_tcon *tcon = NULL;
2012         struct TCP_Server_Info *server;
2013         struct cifs_io_parms io_parms;
2014
2015         /*
2016          * To avoid spurious oplock breaks from server, in the case of
2017          * inodes that we already have open, avoid doing path based
2018          * setting of file size if we can do it by handle.
2019          * This keeps our caching token (oplock) and avoids timeouts
2020          * when the local oplock break takes longer to flush
2021          * writebehind data than the SMB timeout for the SetPathInfo
2022          * request would allow
2023          */
2024         open_file = find_writable_file(cifsInode, true);
2025         if (open_file) {
2026                 tcon = tlink_tcon(open_file->tlink);
2027                 server = tcon->ses->server;
2028                 if (server->ops->set_file_size)
2029                         rc = server->ops->set_file_size(xid, tcon, open_file,
2030                                                         attrs->ia_size, false);
2031                 else
2032                         rc = -ENOSYS;
2033                 cifsFileInfo_put(open_file);
2034                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2035                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2036                         unsigned int bytes_written;
2037
2038                         io_parms.netfid = open_file->fid.netfid;
2039                         io_parms.pid = open_file->pid;
2040                         io_parms.tcon = tcon;
2041                         io_parms.offset = 0;
2042                         io_parms.length = attrs->ia_size;
2043                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
2044                                           NULL, NULL, 1);
2045                         cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
2046                 }
2047         } else
2048                 rc = -EINVAL;
2049
2050         if (!rc)
2051                 goto set_size_out;
2052
2053         if (tcon == NULL) {
2054                 tlink = cifs_sb_tlink(cifs_sb);
2055                 if (IS_ERR(tlink))
2056                         return PTR_ERR(tlink);
2057                 tcon = tlink_tcon(tlink);
2058                 server = tcon->ses->server;
2059         }
2060
2061         /*
2062          * Set file size by pathname rather than by handle either because no
2063          * valid, writeable file handle for it was found or because there was
2064          * an error setting it by handle.
2065          */
2066         if (server->ops->set_path_size)
2067                 rc = server->ops->set_path_size(xid, tcon, full_path,
2068                                                 attrs->ia_size, cifs_sb, false);
2069         else
2070                 rc = -ENOSYS;
2071         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2072         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2073                 __u16 netfid;
2074                 int oplock = 0;
2075
2076                 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
2077                                    GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
2078                                    &oplock, NULL, cifs_sb->local_nls,
2079                                    cifs_remap(cifs_sb));
2080                 if (rc == 0) {
2081                         unsigned int bytes_written;
2082
2083                         io_parms.netfid = netfid;
2084                         io_parms.pid = current->tgid;
2085                         io_parms.tcon = tcon;
2086                         io_parms.offset = 0;
2087                         io_parms.length = attrs->ia_size;
2088                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
2089                                           NULL,  1);
2090                         cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
2091                         CIFSSMBClose(xid, tcon, netfid);
2092                 }
2093         }
2094         if (tlink)
2095                 cifs_put_tlink(tlink);
2096
2097 set_size_out:
2098         if (rc == 0) {
2099                 cifsInode->server_eof = attrs->ia_size;
2100                 cifs_setsize(inode, attrs->ia_size);
2101                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2102         }
2103
2104         return rc;
2105 }
2106
2107 static int
2108 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2109 {
2110         int rc;
2111         unsigned int xid;
2112         char *full_path = NULL;
2113         struct inode *inode = direntry->d_inode;
2114         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2115         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2116         struct tcon_link *tlink;
2117         struct cifs_tcon *pTcon;
2118         struct cifs_unix_set_info_args *args = NULL;
2119         struct cifsFileInfo *open_file;
2120
2121         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2122                  direntry, attrs->ia_valid);
2123
2124         xid = get_xid();
2125
2126         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2127                 attrs->ia_valid |= ATTR_FORCE;
2128
2129         rc = inode_change_ok(inode, attrs);
2130         if (rc < 0)
2131                 goto out;
2132
2133         full_path = build_path_from_dentry(direntry);
2134         if (full_path == NULL) {
2135                 rc = -ENOMEM;
2136                 goto out;
2137         }
2138
2139         /*
2140          * Attempt to flush data before changing attributes. We need to do
2141          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2142          * ownership or mode then we may also need to do this. Here, we take
2143          * the safe way out and just do the flush on all setattr requests. If
2144          * the flush returns error, store it to report later and continue.
2145          *
2146          * BB: This should be smarter. Why bother flushing pages that
2147          * will be truncated anyway? Also, should we error out here if
2148          * the flush returns error?
2149          */
2150         rc = filemap_write_and_wait(inode->i_mapping);
2151         mapping_set_error(inode->i_mapping, rc);
2152         rc = 0;
2153
2154         if (attrs->ia_valid & ATTR_SIZE) {
2155                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2156                 if (rc != 0)
2157                         goto out;
2158         }
2159
2160         /* skip mode change if it's just for clearing setuid/setgid */
2161         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2162                 attrs->ia_valid &= ~ATTR_MODE;
2163
2164         args = kmalloc(sizeof(*args), GFP_KERNEL);
2165         if (args == NULL) {
2166                 rc = -ENOMEM;
2167                 goto out;
2168         }
2169
2170         /* set up the struct */
2171         if (attrs->ia_valid & ATTR_MODE)
2172                 args->mode = attrs->ia_mode;
2173         else
2174                 args->mode = NO_CHANGE_64;
2175
2176         if (attrs->ia_valid & ATTR_UID)
2177                 args->uid = attrs->ia_uid;
2178         else
2179                 args->uid = INVALID_UID; /* no change */
2180
2181         if (attrs->ia_valid & ATTR_GID)
2182                 args->gid = attrs->ia_gid;
2183         else
2184                 args->gid = INVALID_GID; /* no change */
2185
2186         if (attrs->ia_valid & ATTR_ATIME)
2187                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2188         else
2189                 args->atime = NO_CHANGE_64;
2190
2191         if (attrs->ia_valid & ATTR_MTIME)
2192                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2193         else
2194                 args->mtime = NO_CHANGE_64;
2195
2196         if (attrs->ia_valid & ATTR_CTIME)
2197                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2198         else
2199                 args->ctime = NO_CHANGE_64;
2200
2201         args->device = 0;
2202         open_file = find_writable_file(cifsInode, true);
2203         if (open_file) {
2204                 u16 nfid = open_file->fid.netfid;
2205                 u32 npid = open_file->pid;
2206                 pTcon = tlink_tcon(open_file->tlink);
2207                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2208                 cifsFileInfo_put(open_file);
2209         } else {
2210                 tlink = cifs_sb_tlink(cifs_sb);
2211                 if (IS_ERR(tlink)) {
2212                         rc = PTR_ERR(tlink);
2213                         goto out;
2214                 }
2215                 pTcon = tlink_tcon(tlink);
2216                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2217                                     cifs_sb->local_nls,
2218                                     cifs_sb->mnt_cifs_flags &
2219                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
2220                 cifs_put_tlink(tlink);
2221         }
2222
2223         if (rc)
2224                 goto out;
2225
2226         if ((attrs->ia_valid & ATTR_SIZE) &&
2227             attrs->ia_size != i_size_read(inode))
2228                 truncate_setsize(inode, attrs->ia_size);
2229
2230         setattr_copy(inode, attrs);
2231         mark_inode_dirty(inode);
2232
2233         /* force revalidate when any of these times are set since some
2234            of the fs types (eg ext3, fat) do not have fine enough
2235            time granularity to match protocol, and we do not have a
2236            a way (yet) to query the server fs's time granularity (and
2237            whether it rounds times down).
2238         */
2239         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2240                 cifsInode->time = 0;
2241 out:
2242         kfree(args);
2243         kfree(full_path);
2244         free_xid(xid);
2245         return rc;
2246 }
2247
2248 static int
2249 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2250 {
2251         unsigned int xid;
2252         kuid_t uid = INVALID_UID;
2253         kgid_t gid = INVALID_GID;
2254         struct inode *inode = direntry->d_inode;
2255         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2256         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2257         char *full_path = NULL;
2258         int rc = -EACCES;
2259         __u32 dosattr = 0;
2260         __u64 mode = NO_CHANGE_64;
2261
2262         xid = get_xid();
2263
2264         cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2265                  direntry, attrs->ia_valid);
2266
2267         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2268                 attrs->ia_valid |= ATTR_FORCE;
2269
2270         rc = inode_change_ok(inode, attrs);
2271         if (rc < 0) {
2272                 free_xid(xid);
2273                 return rc;
2274         }
2275
2276         full_path = build_path_from_dentry(direntry);
2277         if (full_path == NULL) {
2278                 rc = -ENOMEM;
2279                 free_xid(xid);
2280                 return rc;
2281         }
2282
2283         /*
2284          * Attempt to flush data before changing attributes. We need to do
2285          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2286          * ownership or mode then we may also need to do this. Here, we take
2287          * the safe way out and just do the flush on all setattr requests. If
2288          * the flush returns error, store it to report later and continue.
2289          *
2290          * BB: This should be smarter. Why bother flushing pages that
2291          * will be truncated anyway? Also, should we error out here if
2292          * the flush returns error?
2293          */
2294         rc = filemap_write_and_wait(inode->i_mapping);
2295         mapping_set_error(inode->i_mapping, rc);
2296         rc = 0;
2297
2298         if (attrs->ia_valid & ATTR_SIZE) {
2299                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2300                 if (rc != 0)
2301                         goto cifs_setattr_exit;
2302         }
2303
2304         if (attrs->ia_valid & ATTR_UID)
2305                 uid = attrs->ia_uid;
2306
2307         if (attrs->ia_valid & ATTR_GID)
2308                 gid = attrs->ia_gid;
2309
2310 #ifdef CONFIG_CIFS_ACL
2311         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2312                 if (uid_valid(uid) || gid_valid(gid)) {
2313                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2314                                                         uid, gid);
2315                         if (rc) {
2316                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2317                                          __func__, rc);
2318                                 goto cifs_setattr_exit;
2319                         }
2320                 }
2321         } else
2322 #endif /* CONFIG_CIFS_ACL */
2323         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2324                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2325
2326         /* skip mode change if it's just for clearing setuid/setgid */
2327         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2328                 attrs->ia_valid &= ~ATTR_MODE;
2329
2330         if (attrs->ia_valid & ATTR_MODE) {
2331                 mode = attrs->ia_mode;
2332                 rc = 0;
2333 #ifdef CONFIG_CIFS_ACL
2334                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2335                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2336                                                 INVALID_UID, INVALID_GID);
2337                         if (rc) {
2338                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2339                                          __func__, rc);
2340                                 goto cifs_setattr_exit;
2341                         }
2342                 } else
2343 #endif /* CONFIG_CIFS_ACL */
2344                 if (((mode & S_IWUGO) == 0) &&
2345                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2346
2347                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2348
2349                         /* fix up mode if we're not using dynperm */
2350                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2351                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2352                 } else if ((mode & S_IWUGO) &&
2353                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2354
2355                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2356                         /* Attributes of 0 are ignored */
2357                         if (dosattr == 0)
2358                                 dosattr |= ATTR_NORMAL;
2359
2360                         /* reset local inode permissions to normal */
2361                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2362                                 attrs->ia_mode &= ~(S_IALLUGO);
2363                                 if (S_ISDIR(inode->i_mode))
2364                                         attrs->ia_mode |=
2365                                                 cifs_sb->mnt_dir_mode;
2366                                 else
2367                                         attrs->ia_mode |=
2368                                                 cifs_sb->mnt_file_mode;
2369                         }
2370                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2371                         /* ignore mode change - ATTR_READONLY hasn't changed */
2372                         attrs->ia_valid &= ~ATTR_MODE;
2373                 }
2374         }
2375
2376         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2377             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2378                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2379                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2380
2381                 /* Even if error on time set, no sense failing the call if
2382                 the server would set the time to a reasonable value anyway,
2383                 and this check ensures that we are not being called from
2384                 sys_utimes in which case we ought to fail the call back to
2385                 the user when the server rejects the call */
2386                 if ((rc) && (attrs->ia_valid &
2387                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2388                         rc = 0;
2389         }
2390
2391         /* do not need local check to inode_check_ok since the server does
2392            that */
2393         if (rc)
2394                 goto cifs_setattr_exit;
2395
2396         if ((attrs->ia_valid & ATTR_SIZE) &&
2397             attrs->ia_size != i_size_read(inode))
2398                 truncate_setsize(inode, attrs->ia_size);
2399
2400         setattr_copy(inode, attrs);
2401         mark_inode_dirty(inode);
2402
2403 cifs_setattr_exit:
2404         kfree(full_path);
2405         free_xid(xid);
2406         return rc;
2407 }
2408
2409 int
2410 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2411 {
2412         struct inode *inode = direntry->d_inode;
2413         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2414         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2415
2416         if (pTcon->unix_ext)
2417                 return cifs_setattr_unix(direntry, attrs);
2418
2419         return cifs_setattr_nounix(direntry, attrs);
2420
2421         /* BB: add cifs_setattr_legacy for really old servers */
2422 }
2423
2424 #if 0
2425 void cifs_delete_inode(struct inode *inode)
2426 {
2427         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2428         /* may have to add back in if and when safe distributed caching of
2429            directories added e.g. via FindNotify */
2430 }
2431 #endif