fs/cifs/inode.c

   1 /*
   2  *   fs/cifs/inode.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2010
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/stat.h>
  23 #include <linux/slab.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/freezer.h>
  26 #include <asm/div64.h>
  27 #include "cifsfs.h"
  28 #include "cifspdu.h"
  29 #include "cifsglob.h"
  30 #include "cifsproto.h"
  31 #include "cifs_debug.h"
  32 #include "cifs_fs_sb.h"
  33 #include "cifs_unicode.h"
  34 #include "fscache.h"
  35
  36
  37 static void cifs_set_ops(struct inode *inode)
  38 {
  39         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  40
  41         switch (inode->i_mode & S_IFMT) {
  42         case S_IFREG:
  43                 inode->i_op = &cifs_file_inode_ops;
  44                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  45                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  46                                 inode->i_fop = &cifs_file_direct_nobrl_ops;
  47                         else
  48                                 inode->i_fop = &cifs_file_direct_ops;
  49                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  50                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  51                                 inode->i_fop = &cifs_file_strict_nobrl_ops;
  52                         else
  53                                 inode->i_fop = &cifs_file_strict_ops;
  54                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  55                         inode->i_fop = &cifs_file_nobrl_ops;
  56                 else { /* not direct, send byte range locks */
  57                         inode->i_fop = &cifs_file_ops;
  58                 }
  59
  60                 /* check if server can support readpages */
  61                 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
  62                                 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
  63                         inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  64                 else
  65                         inode->i_data.a_ops = &cifs_addr_ops;
  66                 break;
  67         case S_IFDIR:
  68 #ifdef CONFIG_CIFS_DFS_UPCALL
  69                 if (IS_AUTOMOUNT(inode)) {
  70                         inode->i_op = &cifs_dfs_referral_inode_operations;
  71                 } else {
  72 #else /* NO DFS support, treat as a directory */
  73                 {
  74 #endif
  75                         inode->i_op = &cifs_dir_inode_ops;
  76                         inode->i_fop = &cifs_dir_ops;
  77                 }
  78                 break;
  79         case S_IFLNK:
  80                 inode->i_op = &cifs_symlink_inode_ops;
  81                 break;
  82         default:
  83                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
  84                 break;
  85         }
  86 }
  87
  88 /* check inode attributes against fattr. If they don't match, tag the
  89  * inode for cache invalidation
  90  */
  91 static void
  92 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
  93 {
  94         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
  95
  96         cifs_dbg(FYI, "%s: revalidating inode %llu\n",
  97                  __func__, cifs_i->uniqueid);
  98
  99         if (inode->i_state & I_NEW) {
 100                 cifs_dbg(FYI, "%s: inode %llu is new\n",
 101                          __func__, cifs_i->uniqueid);
 102                 return;
 103         }
 104
 105         /* don't bother with revalidation if we have an oplock */
 106         if (CIFS_CACHE_READ(cifs_i)) {
 107                 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
 108                          __func__, cifs_i->uniqueid);
 109                 return;
 110         }
 111
 112          /* revalidate if mtime or size have changed */
 113         if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
 114             cifs_i->server_eof == fattr->cf_eof) {
 115                 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
 116                          __func__, cifs_i->uniqueid);
 117                 return;
 118         }
 119
 120         cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 121                  __func__, cifs_i->uniqueid);
 122         set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
 123 }
 124
 125 /*
 126  * copy nlink to the inode, unless it wasn't provided.  Provide
 127  * sane values if we don't have an existing one and none was provided
 128  */
 129 static void
 130 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 131 {
 132         /*
 133          * if we're in a situation where we can't trust what we
 134          * got from the server (readdir, some non-unix cases)
 135          * fake reasonable values
 136          */
 137         if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
 138                 /* only provide fake values on a new inode */
 139                 if (inode->i_state & I_NEW) {
 140                         if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
 141                                 set_nlink(inode, 2);
 142                         else
 143                                 set_nlink(inode, 1);
 144                 }
 145                 return;
 146         }
 147
 148         /* we trust the server, so update it */
 149         set_nlink(inode, fattr->cf_nlink);
 150 }
 151
 152 /* populate an inode with info from a cifs_fattr struct */
 153 void
 154 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 155 {
 156         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 157         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 158
 159         cifs_revalidate_cache(inode, fattr);
 160
 161         spin_lock(&inode->i_lock);
 162         inode->i_atime = fattr->cf_atime;
 163         inode->i_mtime = fattr->cf_mtime;
 164         inode->i_ctime = fattr->cf_ctime;
 165         inode->i_rdev = fattr->cf_rdev;
 166         cifs_nlink_fattr_to_inode(inode, fattr);
 167         inode->i_uid = fattr->cf_uid;
 168         inode->i_gid = fattr->cf_gid;
 169
 170         /* if dynperm is set, don't clobber existing mode */
 171         if (inode->i_state & I_NEW ||
 172             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
 173                 inode->i_mode = fattr->cf_mode;
 174
 175         cifs_i->cifsAttrs = fattr->cf_cifsattrs;
 176
 177         if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
 178                 cifs_i->time = 0;
 179         else
 180                 cifs_i->time = jiffies;
 181
 182         if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
 183                 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 184         else
 185                 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 186
 187         cifs_i->server_eof = fattr->cf_eof;
 188         /*
 189          * Can't safely change the file size here if the client is writing to
 190          * it due to potential races.
 191          */
 192         if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
 193                 i_size_write(inode, fattr->cf_eof);
 194
 195                 /*
 196                  * i_blocks is not related to (i_size / i_blksize),
 197                  * but instead 512 byte (2**9) size is required for
 198                  * calculating num blocks.
 199                  */
 200                 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
 201         }
 202         spin_unlock(&inode->i_lock);
 203
 204         if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
 205                 inode->i_flags |= S_AUTOMOUNT;
 206         if (inode->i_state & I_NEW)
 207                 cifs_set_ops(inode);
 208 }
 209
 210 void
 211 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
 212 {
 213         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 214
 215         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 216                 return;
 217
 218         fattr->cf_uniqueid = iunique(sb, ROOT_I);
 219 }
 220
 221 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
 222 void
 223 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
 224                          struct cifs_sb_info *cifs_sb)
 225 {
 226         memset(fattr, 0, sizeof(*fattr));
 227         fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
 228         fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
 229         fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 230
 231         fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 232         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
 233         fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
 234         fattr->cf_mode = le64_to_cpu(info->Permissions);
 235
 236         /*
 237          * Since we set the inode type below we need to mask off
 238          * to avoid strange results if bits set above.
 239          */
 240         fattr->cf_mode &= ~S_IFMT;
 241         switch (le32_to_cpu(info->Type)) {
 242         case UNIX_FILE:
 243                 fattr->cf_mode |= S_IFREG;
 244                 fattr->cf_dtype = DT_REG;
 245                 break;
 246         case UNIX_SYMLINK:
 247                 fattr->cf_mode |= S_IFLNK;
 248                 fattr->cf_dtype = DT_LNK;
 249                 break;
 250         case UNIX_DIR:
 251                 fattr->cf_mode |= S_IFDIR;
 252                 fattr->cf_dtype = DT_DIR;
 253                 break;
 254         case UNIX_CHARDEV:
 255                 fattr->cf_mode |= S_IFCHR;
 256                 fattr->cf_dtype = DT_CHR;
 257                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 258                                        le64_to_cpu(info->DevMinor) & MINORMASK);
 259                 break;
 260         case UNIX_BLOCKDEV:
 261                 fattr->cf_mode |= S_IFBLK;
 262                 fattr->cf_dtype = DT_BLK;
 263                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 264                                        le64_to_cpu(info->DevMinor) & MINORMASK);
 265                 break;
 266         case UNIX_FIFO:
 267                 fattr->cf_mode |= S_IFIFO;
 268                 fattr->cf_dtype = DT_FIFO;
 269                 break;
 270         case UNIX_SOCKET:
 271                 fattr->cf_mode |= S_IFSOCK;
 272                 fattr->cf_dtype = DT_SOCK;
 273                 break;
 274         default:
 275                 /* safest to call it a file if we do not know */
 276                 fattr->cf_mode |= S_IFREG;
 277                 fattr->cf_dtype = DT_REG;
 278                 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
 279                 break;
 280         }
 281
 282         fattr->cf_uid = cifs_sb->mnt_uid;
 283         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
 284                 u64 id = le64_to_cpu(info->Uid);
 285                 if (id < ((uid_t)-1)) {
 286                         kuid_t uid = make_kuid(&init_user_ns, id);
 287                         if (uid_valid(uid))
 288                                 fattr->cf_uid = uid;
 289                 }
 290         }
 291
 292         fattr->cf_gid = cifs_sb->mnt_gid;
 293         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
 294                 u64 id = le64_to_cpu(info->Gid);
 295                 if (id < ((gid_t)-1)) {
 296                         kgid_t gid = make_kgid(&init_user_ns, id);
 297                         if (gid_valid(gid))
 298                                 fattr->cf_gid = gid;
 299                 }
 300         }
 301
 302         fattr->cf_nlink = le64_to_cpu(info->Nlinks);
 303 }
 304
 305 /*
 306  * Fill a cifs_fattr struct with fake inode info.
 307  *
 308  * Needed to setup cifs_fattr data for the directory which is the
 309  * junction to the new submount (ie to setup the fake directory
 310  * which represents a DFS referral).
 311  */
 312 static void
 313 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
 314 {
 315         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 316
 317         cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
 318
 319         memset(fattr, 0, sizeof(*fattr));
 320         fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
 321         fattr->cf_uid = cifs_sb->mnt_uid;
 322         fattr->cf_gid = cifs_sb->mnt_gid;
 323         fattr->cf_atime = CURRENT_TIME;
 324         fattr->cf_ctime = CURRENT_TIME;
 325         fattr->cf_mtime = CURRENT_TIME;
 326         fattr->cf_nlink = 2;
 327         fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
 328 }
 329
 330 static int
 331 cifs_get_file_info_unix(struct file *filp)
 332 {
 333         int rc;
 334         unsigned int xid;
 335         FILE_UNIX_BASIC_INFO find_data;
 336         struct cifs_fattr fattr;
 337         struct inode *inode = file_inode(filp);
 338         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 339         struct cifsFileInfo *cfile = filp->private_data;
 340         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 341
 342         xid = get_xid();
 343         rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
 344         if (!rc) {
 345                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 346         } else if (rc == -EREMOTE) {
 347                 cifs_create_dfs_fattr(&fattr, inode->i_sb);
 348                 rc = 0;
 349         }
 350
 351         cifs_fattr_to_inode(inode, &fattr);
 352         free_xid(xid);
 353         return rc;
 354 }
 355
 356 int cifs_get_inode_info_unix(struct inode **pinode,
 357                              const unsigned char *full_path,
 358                              struct super_block *sb, unsigned int xid)
 359 {
 360         int rc;
 361         FILE_UNIX_BASIC_INFO find_data;
 362         struct cifs_fattr fattr;
 363         struct cifs_tcon *tcon;
 364         struct tcon_link *tlink;
 365         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 366
 367         cifs_dbg(FYI, "Getting info on %s\n", full_path);
 368
 369         tlink = cifs_sb_tlink(cifs_sb);
 370         if (IS_ERR(tlink))
 371                 return PTR_ERR(tlink);
 372         tcon = tlink_tcon(tlink);
 373
 374         /* could have done a find first instead but this returns more info */
 375         rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
 376                                   cifs_sb->local_nls, cifs_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         else
 966                 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
 967
 968         if (!inode) {
 969                 inode = ERR_PTR(rc);
 970                 goto out;
 971         }
 972
 973 #ifdef CONFIG_CIFS_FSCACHE
 974         /* populate tcon->resource_id */
 975         tcon->resource_id = CIFS_I(inode)->uniqueid;
 976 #endif
 977
 978         if (rc && tcon->ipc) {
 979                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
 980                 spin_lock(&inode->i_lock);
 981                 inode->i_mode |= S_IFDIR;
 982                 set_nlink(inode, 2);
 983                 inode->i_op = &cifs_ipc_inode_ops;
 984                 inode->i_fop = &simple_dir_operations;
 985                 inode->i_uid = cifs_sb->mnt_uid;
 986                 inode->i_gid = cifs_sb->mnt_gid;
 987                 spin_unlock(&inode->i_lock);
 988         } else if (rc) {
 989                 iget_failed(inode);
 990                 inode = ERR_PTR(rc);
 991         }
 992
 993 out:
 994         /* can not call macro free_xid here since in a void func
 995          * TODO: This is no longer true
 996          */
 997         _free_xid(xid);
 998         return inode;
 999 }
1000
1001 int
1002 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1003                    char *full_path, __u32 dosattr)
1004 {
1005         bool set_time = false;
1006         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1007         struct TCP_Server_Info *server;
1008         FILE_BASIC_INFO info_buf;
1009
1010         if (attrs == NULL)
1011                 return -EINVAL;
1012
1013         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1014         if (!server->ops->set_file_info)
1015                 return -ENOSYS;
1016
1017         if (attrs->ia_valid & ATTR_ATIME) {
1018                 set_time = true;
1019                 info_buf.LastAccessTime =
1020                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1021         } else
1022                 info_buf.LastAccessTime = 0;
1023
1024         if (attrs->ia_valid & ATTR_MTIME) {
1025                 set_time = true;
1026                 info_buf.LastWriteTime =
1027                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1028         } else
1029                 info_buf.LastWriteTime = 0;
1030
1031         /*
1032          * Samba throws this field away, but windows may actually use it.
1033          * Do not set ctime unless other time stamps are changed explicitly
1034          * (i.e. by utimes()) since we would then have a mix of client and
1035          * server times.
1036          */
1037         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1038                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1039                 info_buf.ChangeTime =
1040                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1041         } else
1042                 info_buf.ChangeTime = 0;
1043
1044         info_buf.CreationTime = 0;      /* don't change */
1045         info_buf.Attributes = cpu_to_le32(dosattr);
1046
1047         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1048 }
1049
1050 /*
1051  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1052  * and rename it to a random name that hopefully won't conflict with
1053  * anything else.
1054  */
1055 int
1056 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1057                            const unsigned int xid)
1058 {
1059         int oplock = 0;
1060         int rc;
1061         struct cifs_fid fid;
1062         struct cifs_open_parms oparms;
1063         struct inode *inode = dentry->d_inode;
1064         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1065         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1066         struct tcon_link *tlink;
1067         struct cifs_tcon *tcon;
1068         __u32 dosattr, origattr;
1069         FILE_BASIC_INFO *info_buf = NULL;
1070
1071         tlink = cifs_sb_tlink(cifs_sb);
1072         if (IS_ERR(tlink))
1073                 return PTR_ERR(tlink);
1074         tcon = tlink_tcon(tlink);
1075
1076         /*
1077          * We cannot rename the file if the server doesn't support
1078          * CAP_INFOLEVEL_PASSTHRU
1079          */
1080         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1081                 rc = -EBUSY;
1082                 goto out;
1083         }
1084
1085         oparms.tcon = tcon;
1086         oparms.cifs_sb = cifs_sb;
1087         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1088         oparms.create_options = CREATE_NOT_DIR;
1089         oparms.disposition = FILE_OPEN;
1090         oparms.path = full_path;
1091         oparms.fid = &fid;
1092         oparms.reconnect = false;
1093
1094         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1095         if (rc != 0)
1096                 goto out;
1097
1098         origattr = cifsInode->cifsAttrs;
1099         if (origattr == 0)
1100                 origattr |= ATTR_NORMAL;
1101
1102         dosattr = origattr & ~ATTR_READONLY;
1103         if (dosattr == 0)
1104                 dosattr |= ATTR_NORMAL;
1105         dosattr |= ATTR_HIDDEN;
1106
1107         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1108         if (dosattr != origattr) {
1109                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1110                 if (info_buf == NULL) {
1111                         rc = -ENOMEM;
1112                         goto out_close;
1113                 }
1114                 info_buf->Attributes = cpu_to_le32(dosattr);
1115                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1116                                         current->tgid);
1117                 /* although we would like to mark the file hidden
1118                    if that fails we will still try to rename it */
1119                 if (!rc)
1120                         cifsInode->cifsAttrs = dosattr;
1121                 else
1122                         dosattr = origattr; /* since not able to change them */
1123         }
1124
1125         /* rename the file */
1126         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1127                                    cifs_sb->local_nls,
1128                                    cifs_remap(cifs_sb));
1129         if (rc != 0) {
1130                 rc = -EBUSY;
1131                 goto undo_setattr;
1132         }
1133
1134         /* try to set DELETE_ON_CLOSE */
1135         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1136                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1137                                                current->tgid);
1138                 /*
1139                  * some samba versions return -ENOENT when we try to set the
1140                  * file disposition here. Likely a samba bug, but work around
1141                  * it for now. This means that some cifsXXX files may hang
1142                  * around after they shouldn't.
1143                  *
1144                  * BB: remove this hack after more servers have the fix
1145                  */
1146                 if (rc == -ENOENT)
1147                         rc = 0;
1148                 else if (rc != 0) {
1149                         rc = -EBUSY;
1150                         goto undo_rename;
1151                 }
1152                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1153         }
1154
1155 out_close:
1156         CIFSSMBClose(xid, tcon, fid.netfid);
1157 out:
1158         kfree(info_buf);
1159         cifs_put_tlink(tlink);
1160         return rc;
1161
1162         /*
1163          * reset everything back to the original state. Don't bother
1164          * dealing with errors here since we can't do anything about
1165          * them anyway.
1166          */
1167 undo_rename:
1168         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1169                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1170 undo_setattr:
1171         if (dosattr != origattr) {
1172                 info_buf->Attributes = cpu_to_le32(origattr);
1173                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1174                                         current->tgid))
1175                         cifsInode->cifsAttrs = origattr;
1176         }
1177
1178         goto out_close;
1179 }
1180
1181 /* copied from fs/nfs/dir.c with small changes */
1182 static void
1183 cifs_drop_nlink(struct inode *inode)
1184 {
1185         spin_lock(&inode->i_lock);
1186         if (inode->i_nlink > 0)
1187                 drop_nlink(inode);
1188         spin_unlock(&inode->i_lock);
1189 }
1190
1191 /*
1192  * If dentry->d_inode is null (usually meaning the cached dentry
1193  * is a negative dentry) then we would attempt a standard SMB delete, but
1194  * if that fails we can not attempt the fall back mechanisms on EACCESS
1195  * but will return the EACCESS to the caller. Note that the VFS does not call
1196  * unlink on negative dentries currently.
1197  */
1198 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1199 {
1200         int rc = 0;
1201         unsigned int xid;
1202         char *full_path = NULL;
1203         struct inode *inode = dentry->d_inode;
1204         struct cifsInodeInfo *cifs_inode;
1205         struct super_block *sb = dir->i_sb;
1206         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1207         struct tcon_link *tlink;
1208         struct cifs_tcon *tcon;
1209         struct TCP_Server_Info *server;
1210         struct iattr *attrs = NULL;
1211         __u32 dosattr = 0, origattr = 0;
1212
1213         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1214
1215         tlink = cifs_sb_tlink(cifs_sb);
1216         if (IS_ERR(tlink))
1217                 return PTR_ERR(tlink);
1218         tcon = tlink_tcon(tlink);
1219         server = tcon->ses->server;
1220
1221         xid = get_xid();
1222
1223         /* Unlink can be called from rename so we can not take the
1224          * sb->s_vfs_rename_mutex here */
1225         full_path = build_path_from_dentry(dentry);
1226         if (full_path == NULL) {
1227                 rc = -ENOMEM;
1228                 goto unlink_out;
1229         }
1230
1231         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1232                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1233                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1234                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1235                         cifs_remap(cifs_sb));
1236                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1237                 if ((rc == 0) || (rc == -ENOENT))
1238                         goto psx_del_no_retry;
1239         }
1240
1241 retry_std_delete:
1242         if (!server->ops->unlink) {
1243                 rc = -ENOSYS;
1244                 goto psx_del_no_retry;
1245         }
1246
1247         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1248
1249 psx_del_no_retry:
1250         if (!rc) {
1251                 if (inode)
1252                         cifs_drop_nlink(inode);
1253         } else if (rc == -ENOENT) {
1254                 d_drop(dentry);
1255         } else if (rc == -EBUSY) {
1256                 if (server->ops->rename_pending_delete) {
1257                         rc = server->ops->rename_pending_delete(full_path,
1258                                                                 dentry, xid);
1259                         if (rc == 0)
1260                                 cifs_drop_nlink(inode);
1261                 }
1262         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1263                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1264                 if (attrs == NULL) {
1265                         rc = -ENOMEM;
1266                         goto out_reval;
1267                 }
1268
1269                 /* try to reset dos attributes */
1270                 cifs_inode = CIFS_I(inode);
1271                 origattr = cifs_inode->cifsAttrs;
1272                 if (origattr == 0)
1273                         origattr |= ATTR_NORMAL;
1274                 dosattr = origattr & ~ATTR_READONLY;
1275                 if (dosattr == 0)
1276                         dosattr |= ATTR_NORMAL;
1277                 dosattr |= ATTR_HIDDEN;
1278
1279                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1280                 if (rc != 0)
1281                         goto out_reval;
1282
1283                 goto retry_std_delete;
1284         }
1285
1286         /* undo the setattr if we errored out and it's needed */
1287         if (rc != 0 && dosattr != 0)
1288                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1289
1290 out_reval:
1291         if (inode) {
1292                 cifs_inode = CIFS_I(inode);
1293                 cifs_inode->time = 0;   /* will force revalidate to get info
1294                                            when needed */
1295                 inode->i_ctime = current_fs_time(sb);
1296         }
1297         dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1298         cifs_inode = CIFS_I(dir);
1299         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1300 unlink_out:
1301         kfree(full_path);
1302         kfree(attrs);
1303         free_xid(xid);
1304         cifs_put_tlink(tlink);
1305         return rc;
1306 }
1307
1308 static int
1309 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1310                  const char *full_path, struct cifs_sb_info *cifs_sb,
1311                  struct cifs_tcon *tcon, const unsigned int xid)
1312 {
1313         int rc = 0;
1314         struct inode *inode = NULL;
1315
1316         if (tcon->unix_ext)
1317                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1318                                               xid);
1319         else
1320                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1321                                          xid, NULL);
1322
1323         if (rc)
1324                 return rc;
1325
1326         /*
1327          * setting nlink not necessary except in cases where we failed to get it
1328          * from the server or was set bogus. Also, since this is a brand new
1329          * inode, no need to grab the i_lock before setting the i_nlink.
1330          */
1331         if (inode->i_nlink < 2)
1332                 set_nlink(inode, 2);
1333         mode &= ~current_umask();
1334         /* must turn on setgid bit if parent dir has it */
1335         if (parent->i_mode & S_ISGID)
1336                 mode |= S_ISGID;
1337
1338         if (tcon->unix_ext) {
1339                 struct cifs_unix_set_info_args args = {
1340                         .mode   = mode,
1341                         .ctime  = NO_CHANGE_64,
1342                         .atime  = NO_CHANGE_64,
1343                         .mtime  = NO_CHANGE_64,
1344                         .device = 0,
1345                 };
1346                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1347                         args.uid = current_fsuid();
1348                         if (parent->i_mode & S_ISGID)
1349                                 args.gid = parent->i_gid;
1350                         else
1351                                 args.gid = current_fsgid();
1352                 } else {
1353                         args.uid = INVALID_UID; /* no change */
1354                         args.gid = INVALID_GID; /* no change */
1355                 }
1356                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1357                                        cifs_sb->local_nls,
1358                                        cifs_remap(cifs_sb));
1359         } else {
1360                 struct TCP_Server_Info *server = tcon->ses->server;
1361                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1362                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1363                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1364                                                    tcon, xid);
1365                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1366                         inode->i_mode = (mode | S_IFDIR);
1367
1368                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1369                         inode->i_uid = current_fsuid();
1370                         if (inode->i_mode & S_ISGID)
1371                                 inode->i_gid = parent->i_gid;
1372                         else
1373                                 inode->i_gid = current_fsgid();
1374                 }
1375         }
1376         d_instantiate(dentry, inode);
1377         return rc;
1378 }
1379
1380 static int
1381 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1382                  const char *full_path, struct cifs_sb_info *cifs_sb,
1383                  struct cifs_tcon *tcon, const unsigned int xid)
1384 {
1385         int rc = 0;
1386         u32 oplock = 0;
1387         FILE_UNIX_BASIC_INFO *info = NULL;
1388         struct inode *newinode = NULL;
1389         struct cifs_fattr fattr;
1390
1391         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1392         if (info == NULL) {
1393                 rc = -ENOMEM;
1394                 goto posix_mkdir_out;
1395         }
1396
1397         mode &= ~current_umask();
1398         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1399                              NULL /* netfid */, info, &oplock, full_path,
1400                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1401         if (rc == -EOPNOTSUPP)
1402                 goto posix_mkdir_out;
1403         else if (rc) {
1404                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1405                 d_drop(dentry);
1406                 goto posix_mkdir_out;
1407         }
1408
1409         if (info->Type == cpu_to_le32(-1))
1410                 /* no return info, go query for it */
1411                 goto posix_mkdir_get_info;
1412         /*
1413          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1414          * need to set uid/gid.
1415          */
1416
1417         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1418         cifs_fill_uniqueid(inode->i_sb, &fattr);
1419         newinode = cifs_iget(inode->i_sb, &fattr);
1420         if (!newinode)
1421                 goto posix_mkdir_get_info;
1422
1423         d_instantiate(dentry, newinode);
1424
1425 #ifdef CONFIG_CIFS_DEBUG2
1426         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1427                  dentry, dentry, newinode);
1428
1429         if (newinode->i_nlink != 2)
1430                 cifs_dbg(FYI, "unexpected number of links %d\n",
1431                          newinode->i_nlink);
1432 #endif
1433
1434 posix_mkdir_out:
1435         kfree(info);
1436         return rc;
1437 posix_mkdir_get_info:
1438         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1439                               xid);
1440         goto posix_mkdir_out;
1441 }
1442
1443 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1444 {
1445         int rc = 0;
1446         unsigned int xid;
1447         struct cifs_sb_info *cifs_sb;
1448         struct tcon_link *tlink;
1449         struct cifs_tcon *tcon;
1450         struct TCP_Server_Info *server;
1451         char *full_path;
1452
1453         cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1454                  mode, inode);
1455
1456         cifs_sb = CIFS_SB(inode->i_sb);
1457         tlink = cifs_sb_tlink(cifs_sb);
1458         if (IS_ERR(tlink))
1459                 return PTR_ERR(tlink);
1460         tcon = tlink_tcon(tlink);
1461
1462         xid = get_xid();
1463
1464         full_path = build_path_from_dentry(direntry);
1465         if (full_path == NULL) {
1466                 rc = -ENOMEM;
1467                 goto mkdir_out;
1468         }
1469
1470         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1471                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1472                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1473                                       tcon, xid);
1474                 if (rc != -EOPNOTSUPP)
1475                         goto mkdir_out;
1476         }
1477
1478         server = tcon->ses->server;
1479
1480         if (!server->ops->mkdir) {
1481                 rc = -ENOSYS;
1482                 goto mkdir_out;
1483         }
1484
1485         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1486         rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1487         if (rc) {
1488                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1489                 d_drop(direntry);
1490                 goto mkdir_out;
1491         }
1492
1493         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1494                               xid);
1495 mkdir_out:
1496         /*
1497          * Force revalidate to get parent dir info when needed since cached
1498          * attributes are invalid now.
1499          */
1500         CIFS_I(inode)->time = 0;
1501         kfree(full_path);
1502         free_xid(xid);
1503         cifs_put_tlink(tlink);
1504         return rc;
1505 }
1506
1507 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1508 {
1509         int rc = 0;
1510         unsigned int xid;
1511         struct cifs_sb_info *cifs_sb;
1512         struct tcon_link *tlink;
1513         struct cifs_tcon *tcon;
1514         struct TCP_Server_Info *server;
1515         char *full_path = NULL;
1516         struct cifsInodeInfo *cifsInode;
1517
1518         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1519
1520         xid = get_xid();
1521
1522         full_path = build_path_from_dentry(direntry);
1523         if (full_path == NULL) {
1524                 rc = -ENOMEM;
1525                 goto rmdir_exit;
1526         }
1527
1528         cifs_sb = CIFS_SB(inode->i_sb);
1529         tlink = cifs_sb_tlink(cifs_sb);
1530         if (IS_ERR(tlink)) {
1531                 rc = PTR_ERR(tlink);
1532                 goto rmdir_exit;
1533         }
1534         tcon = tlink_tcon(tlink);
1535         server = tcon->ses->server;
1536
1537         if (!server->ops->rmdir) {
1538                 rc = -ENOSYS;
1539                 cifs_put_tlink(tlink);
1540                 goto rmdir_exit;
1541         }
1542
1543         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1544         cifs_put_tlink(tlink);
1545
1546         if (!rc) {
1547                 spin_lock(&direntry->d_inode->i_lock);
1548                 i_size_write(direntry->d_inode, 0);
1549                 clear_nlink(direntry->d_inode);
1550                 spin_unlock(&direntry->d_inode->i_lock);
1551         }
1552
1553         cifsInode = CIFS_I(direntry->d_inode);
1554         /* force revalidate to go get info when needed */
1555         cifsInode->time = 0;
1556
1557         cifsInode = CIFS_I(inode);
1558         /*
1559          * Force revalidate to get parent dir info when needed since cached
1560          * attributes are invalid now.
1561          */
1562         cifsInode->time = 0;
1563
1564         direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1565                 current_fs_time(inode->i_sb);
1566
1567 rmdir_exit:
1568         kfree(full_path);
1569         free_xid(xid);
1570         return rc;
1571 }
1572
1573 static int
1574 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1575                const char *from_path, struct dentry *to_dentry,
1576                const char *to_path)
1577 {
1578         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1579         struct tcon_link *tlink;
1580         struct cifs_tcon *tcon;
1581         struct TCP_Server_Info *server;
1582         struct cifs_fid fid;
1583         struct cifs_open_parms oparms;
1584         int oplock, rc;
1585
1586         tlink = cifs_sb_tlink(cifs_sb);
1587         if (IS_ERR(tlink))
1588                 return PTR_ERR(tlink);
1589         tcon = tlink_tcon(tlink);
1590         server = tcon->ses->server;
1591
1592         if (!server->ops->rename)
1593                 return -ENOSYS;
1594
1595         /* try path-based rename first */
1596         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1597
1598         /*
1599          * Don't bother with rename by filehandle unless file is busy and
1600          * source. Note that cross directory moves do not work with
1601          * rename by filehandle to various Windows servers.
1602          */
1603         if (rc == 0 || rc != -EBUSY)
1604                 goto do_rename_exit;
1605
1606         /* open-file renames don't work across directories */
1607         if (to_dentry->d_parent != from_dentry->d_parent)
1608                 goto do_rename_exit;
1609
1610         oparms.tcon = tcon;
1611         oparms.cifs_sb = cifs_sb;
1612         /* open the file to be renamed -- we need DELETE perms */
1613         oparms.desired_access = DELETE;
1614         oparms.create_options = CREATE_NOT_DIR;
1615         oparms.disposition = FILE_OPEN;
1616         oparms.path = from_path;
1617         oparms.fid = &fid;
1618         oparms.reconnect = false;
1619
1620         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1621         if (rc == 0) {
1622                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1623                                 (const char *) to_dentry->d_name.name,
1624                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1625                 CIFSSMBClose(xid, tcon, fid.netfid);
1626         }
1627 do_rename_exit:
1628         cifs_put_tlink(tlink);
1629         return rc;
1630 }
1631
1632 int
1633 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1634              struct inode *target_dir, struct dentry *target_dentry,
1635              unsigned int flags)
1636 {
1637         char *from_name = NULL;
1638         char *to_name = NULL;
1639         struct cifs_sb_info *cifs_sb;
1640         struct tcon_link *tlink;
1641         struct cifs_tcon *tcon;
1642         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1643         FILE_UNIX_BASIC_INFO *info_buf_target;
1644         unsigned int xid;
1645         int rc, tmprc;
1646
1647         if (flags & ~RENAME_NOREPLACE)
1648                 return -EINVAL;
1649
1650         cifs_sb = CIFS_SB(source_dir->i_sb);
1651         tlink = cifs_sb_tlink(cifs_sb);
1652         if (IS_ERR(tlink))
1653                 return PTR_ERR(tlink);
1654         tcon = tlink_tcon(tlink);
1655
1656         xid = get_xid();
1657
1658         /*
1659          * we already have the rename sem so we do not need to
1660          * grab it again here to protect the path integrity
1661          */
1662         from_name = build_path_from_dentry(source_dentry);
1663         if (from_name == NULL) {
1664                 rc = -ENOMEM;
1665                 goto cifs_rename_exit;
1666         }
1667
1668         to_name = build_path_from_dentry(target_dentry);
1669         if (to_name == NULL) {
1670                 rc = -ENOMEM;
1671                 goto cifs_rename_exit;
1672         }
1673
1674         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1675                             to_name);
1676
1677         /*
1678          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1679          */
1680         if (flags & RENAME_NOREPLACE)
1681                 goto cifs_rename_exit;
1682
1683         if (rc == -EEXIST && tcon->unix_ext) {
1684                 /*
1685                  * Are src and dst hardlinks of same inode? We can only tell
1686                  * with unix extensions enabled.
1687                  */
1688                 info_buf_source =
1689                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1690                                         GFP_KERNEL);
1691                 if (info_buf_source == NULL) {
1692                         rc = -ENOMEM;
1693                         goto cifs_rename_exit;
1694                 }
1695
1696                 info_buf_target = info_buf_source + 1;
1697                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1698                                              info_buf_source,
1699                                              cifs_sb->local_nls,
1700                                              cifs_remap(cifs_sb));
1701                 if (tmprc != 0)
1702                         goto unlink_target;
1703
1704                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1705                                              info_buf_target,
1706                                              cifs_sb->local_nls,
1707                                              cifs_remap(cifs_sb));
1708
1709                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1710                                    info_buf_target->UniqueId)) {
1711                         /* same file, POSIX says that this is a noop */
1712                         rc = 0;
1713                         goto cifs_rename_exit;
1714                 }
1715         }
1716         /*
1717          * else ... BB we could add the same check for Windows by
1718          * checking the UniqueId via FILE_INTERNAL_INFO
1719          */
1720
1721 unlink_target:
1722         /* Try unlinking the target dentry if it's not negative */
1723         if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1724                 if (d_is_dir(target_dentry))
1725                         tmprc = cifs_rmdir(target_dir, target_dentry);
1726                 else
1727                         tmprc = cifs_unlink(target_dir, target_dentry);
1728                 if (tmprc)
1729                         goto cifs_rename_exit;
1730                 rc = cifs_do_rename(xid, source_dentry, from_name,
1731                                     target_dentry, to_name);
1732         }
1733
1734         /* force revalidate to go get info when needed */
1735         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1736
1737         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1738                 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1739
1740 cifs_rename_exit:
1741         kfree(info_buf_source);
1742         kfree(from_name);
1743         kfree(to_name);
1744         free_xid(xid);
1745         cifs_put_tlink(tlink);
1746         return rc;
1747 }
1748
1749 static bool
1750 cifs_inode_needs_reval(struct inode *inode)
1751 {
1752         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1753         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1754
1755         if (CIFS_CACHE_READ(cifs_i))
1756                 return false;
1757
1758         if (!lookupCacheEnabled)
1759                 return true;
1760
1761         if (cifs_i->time == 0)
1762                 return true;
1763
1764         if (!cifs_sb->actimeo)
1765                 return true;
1766
1767         if (!time_in_range(jiffies, cifs_i->time,
1768                                 cifs_i->time + cifs_sb->actimeo))
1769                 return true;
1770
1771         /* hardlinked files w/ noserverino get "special" treatment */
1772         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1773             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1774                 return true;
1775
1776         return false;
1777 }
1778
1779 /*
1780  * Zap the cache. Called when invalid_mapping flag is set.
1781  */
1782 int
1783 cifs_invalidate_mapping(struct inode *inode)
1784 {
1785         int rc = 0;
1786
1787         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1788                 rc = invalidate_inode_pages2(inode->i_mapping);
1789                 if (rc)
1790                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1791                                  __func__, inode);
1792         }
1793
1794         cifs_fscache_reset_inode_cookie(inode);
1795         return rc;
1796 }
1797
1798 /**
1799  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1800  * @word: long word containing the bit lock
1801  */
1802 static int
1803 cifs_wait_bit_killable(struct wait_bit_key *key)
1804 {
1805         if (fatal_signal_pending(current))
1806                 return -ERESTARTSYS;
1807         freezable_schedule_unsafe();
1808         return 0;
1809 }
1810
1811 int
1812 cifs_revalidate_mapping(struct inode *inode)
1813 {
1814         int rc;
1815         unsigned long *flags = &CIFS_I(inode)->flags;
1816
1817         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1818                                      TASK_KILLABLE);
1819         if (rc)
1820                 return rc;
1821
1822         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1823                 rc = cifs_invalidate_mapping(inode);
1824                 if (rc)
1825                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1826         }
1827
1828         clear_bit_unlock(CIFS_INO_LOCK, flags);
1829         smp_mb__after_atomic();
1830         wake_up_bit(flags, CIFS_INO_LOCK);
1831
1832         return rc;
1833 }
1834
1835 int
1836 cifs_zap_mapping(struct inode *inode)
1837 {
1838         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1839         return cifs_revalidate_mapping(inode);
1840 }
1841
1842 int cifs_revalidate_file_attr(struct file *filp)
1843 {
1844         int rc = 0;
1845         struct inode *inode = file_inode(filp);
1846         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1847
1848         if (!cifs_inode_needs_reval(inode))
1849                 return rc;
1850
1851         if (tlink_tcon(cfile->tlink)->unix_ext)
1852                 rc = cifs_get_file_info_unix(filp);
1853         else
1854                 rc = cifs_get_file_info(filp);
1855
1856         return rc;
1857 }
1858
1859 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1860 {
1861         unsigned int xid;
1862         int rc = 0;
1863         struct inode *inode = dentry->d_inode;
1864         struct super_block *sb = dentry->d_sb;
1865         char *full_path = NULL;
1866
1867         if (inode == NULL)
1868                 return -ENOENT;
1869
1870         if (!cifs_inode_needs_reval(inode))
1871                 return rc;
1872
1873         xid = get_xid();
1874
1875         /* can not safely grab the rename sem here if rename calls revalidate
1876            since that would deadlock */
1877         full_path = build_path_from_dentry(dentry);
1878         if (full_path == NULL) {
1879                 rc = -ENOMEM;
1880                 goto out;
1881         }
1882
1883         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1884                  full_path, inode, inode->i_count.counter,
1885                  dentry, dentry->d_time, jiffies);
1886
1887         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1888                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1889         else
1890                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1891                                          xid, NULL);
1892
1893 out:
1894         kfree(full_path);
1895         free_xid(xid);
1896         return rc;
1897 }
1898
1899 int cifs_revalidate_file(struct file *filp)
1900 {
1901         int rc;
1902         struct inode *inode = file_inode(filp);
1903
1904         rc = cifs_revalidate_file_attr(filp);
1905         if (rc)
1906                 return rc;
1907
1908         return cifs_revalidate_mapping(inode);
1909 }
1910
1911 /* revalidate a dentry's inode attributes */
1912 int cifs_revalidate_dentry(struct dentry *dentry)
1913 {
1914         int rc;
1915         struct inode *inode = dentry->d_inode;
1916
1917         rc = cifs_revalidate_dentry_attr(dentry);
1918         if (rc)
1919                 return rc;
1920
1921         return cifs_revalidate_mapping(inode);
1922 }
1923
1924 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1925                  struct kstat *stat)
1926 {
1927         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1928         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1929         struct inode *inode = dentry->d_inode;
1930         int rc;
1931
1932         /*
1933          * We need to be sure that all dirty pages are written and the server
1934          * has actual ctime, mtime and file length.
1935          */
1936         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1937             inode->i_mapping->nrpages != 0) {
1938                 rc = filemap_fdatawait(inode->i_mapping);
1939                 if (rc) {
1940                         mapping_set_error(inode->i_mapping, rc);
1941                         return rc;
1942                 }
1943         }
1944
1945         rc = cifs_revalidate_dentry_attr(dentry);
1946         if (rc)
1947                 return rc;
1948
1949         generic_fillattr(inode, stat);
1950         stat->blksize = CIFS_MAX_MSGSIZE;
1951         stat->ino = CIFS_I(inode)->uniqueid;
1952
1953         /*
1954          * If on a multiuser mount without unix extensions or cifsacl being
1955          * enabled, and the admin hasn't overridden them, set the ownership
1956          * to the fsuid/fsgid of the current process.
1957          */
1958         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1959             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1960             !tcon->unix_ext) {
1961                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1962                         stat->uid = current_fsuid();
1963                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1964                         stat->gid = current_fsgid();
1965         }
1966         return rc;
1967 }
1968
1969 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1970 {
1971         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1972         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1973         struct page *page;
1974         int rc = 0;
1975
1976         page = grab_cache_page(mapping, index);
1977         if (!page)
1978                 return -ENOMEM;
1979
1980         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1981         unlock_page(page);
1982         page_cache_release(page);
1983         return rc;
1984 }
1985
1986 static void cifs_setsize(struct inode *inode, loff_t offset)
1987 {
1988         spin_lock(&inode->i_lock);
1989         i_size_write(inode, offset);
1990         spin_unlock(&inode->i_lock);
1991
1992         truncate_pagecache(inode, offset);
1993 }
1994
1995 static int
1996 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1997                    unsigned int xid, char *full_path)
1998 {
1999         int rc;
2000         struct cifsFileInfo *open_file;
2001         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2002         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2003         struct tcon_link *tlink = NULL;
2004         struct cifs_tcon *tcon = NULL;
2005         struct TCP_Server_Info *server;
2006         struct cifs_io_parms io_parms;
2007
2008         /*
2009          * To avoid spurious oplock breaks from server, in the case of
2010          * inodes that we already have open, avoid doing path based
2011          * setting of file size if we can do it by handle.
2012          * This keeps our caching token (oplock) and avoids timeouts
2013          * when the local oplock break takes longer to flush
2014          * writebehind data than the SMB timeout for the SetPathInfo
2015          * request would allow
2016          */
2017         open_file = find_writable_file(cifsInode, true);
2018         if (open_file) {
2019                 tcon = tlink_tcon(open_file->tlink);
2020                 server = tcon->ses->server;
2021                 if (server->ops->set_file_size)
2022                         rc = server->ops->set_file_size(xid, tcon, open_file,
2023                                                         attrs->ia_size, false);
2024                 else
2025                         rc = -ENOSYS;
2026                 cifsFileInfo_put(open_file);
2027                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2028                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2029                         unsigned int bytes_written;
2030
2031                         io_parms.netfid = open_file->fid.netfid;
2032                         io_parms.pid = open_file->pid;
2033                         io_parms.tcon = tcon;
2034                         io_parms.offset = 0;
2035                         io_parms.length = attrs->ia_size;
2036                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
2037                                           NULL, NULL, 1);
2038                         cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
2039                 }
2040         } else
2041                 rc = -EINVAL;
2042
2043         if (!rc)
2044                 goto set_size_out;
2045
2046         if (tcon == NULL) {
2047                 tlink = cifs_sb_tlink(cifs_sb);
2048                 if (IS_ERR(tlink))
2049                         return PTR_ERR(tlink);
2050                 tcon = tlink_tcon(tlink);
2051                 server = tcon->ses->server;
2052         }
2053
2054         /*
2055          * Set file size by pathname rather than by handle either because no
2056          * valid, writeable file handle for it was found or because there was
2057          * an error setting it by handle.
2058          */
2059         if (server->ops->set_path_size)
2060                 rc = server->ops->set_path_size(xid, tcon, full_path,
2061                                                 attrs->ia_size, cifs_sb, false);
2062         else
2063                 rc = -ENOSYS;
2064         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2065         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2066                 __u16 netfid;
2067                 int oplock = 0;
2068
2069                 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
2070                                    GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
2071                                    &oplock, NULL, cifs_sb->local_nls,
2072                                    cifs_remap(cifs_sb));
2073                 if (rc == 0) {
2074                         unsigned int bytes_written;
2075
2076                         io_parms.netfid = netfid;
2077                         io_parms.pid = current->tgid;
2078                         io_parms.tcon = tcon;
2079                         io_parms.offset = 0;
2080                         io_parms.length = attrs->ia_size;
2081                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
2082                                           NULL,  1);
2083                         cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
2084                         CIFSSMBClose(xid, tcon, netfid);
2085                 }
2086         }
2087         if (tlink)
2088                 cifs_put_tlink(tlink);
2089
2090 set_size_out:
2091         if (rc == 0) {
2092                 cifsInode->server_eof = attrs->ia_size;
2093                 cifs_setsize(inode, attrs->ia_size);
2094                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2095         }
2096
2097         return rc;
2098 }
2099
2100 static int
2101 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2102 {
2103         int rc;
2104         unsigned int xid;
2105         char *full_path = NULL;
2106         struct inode *inode = direntry->d_inode;
2107         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2108         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2109         struct tcon_link *tlink;
2110         struct cifs_tcon *pTcon;
2111         struct cifs_unix_set_info_args *args = NULL;
2112         struct cifsFileInfo *open_file;
2113
2114         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2115                  direntry, attrs->ia_valid);
2116
2117         xid = get_xid();
2118
2119         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2120                 attrs->ia_valid |= ATTR_FORCE;
2121
2122         rc = inode_change_ok(inode, attrs);
2123         if (rc < 0)
2124                 goto out;
2125
2126         full_path = build_path_from_dentry(direntry);
2127         if (full_path == NULL) {
2128                 rc = -ENOMEM;
2129                 goto out;
2130         }
2131
2132         /*
2133          * Attempt to flush data before changing attributes. We need to do
2134          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2135          * ownership or mode then we may also need to do this. Here, we take
2136          * the safe way out and just do the flush on all setattr requests. If
2137          * the flush returns error, store it to report later and continue.
2138          *
2139          * BB: This should be smarter. Why bother flushing pages that
2140          * will be truncated anyway? Also, should we error out here if
2141          * the flush returns error?
2142          */
2143         rc = filemap_write_and_wait(inode->i_mapping);
2144         mapping_set_error(inode->i_mapping, rc);
2145         rc = 0;
2146
2147         if (attrs->ia_valid & ATTR_SIZE) {
2148                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2149                 if (rc != 0)
2150                         goto out;
2151         }
2152
2153         /* skip mode change if it's just for clearing setuid/setgid */
2154         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2155                 attrs->ia_valid &= ~ATTR_MODE;
2156
2157         args = kmalloc(sizeof(*args), GFP_KERNEL);
2158         if (args == NULL) {
2159                 rc = -ENOMEM;
2160                 goto out;
2161         }
2162
2163         /* set up the struct */
2164         if (attrs->ia_valid & ATTR_MODE)
2165                 args->mode = attrs->ia_mode;
2166         else
2167                 args->mode = NO_CHANGE_64;
2168
2169         if (attrs->ia_valid & ATTR_UID)
2170                 args->uid = attrs->ia_uid;
2171         else
2172                 args->uid = INVALID_UID; /* no change */
2173
2174         if (attrs->ia_valid & ATTR_GID)
2175                 args->gid = attrs->ia_gid;
2176         else
2177                 args->gid = INVALID_GID; /* no change */
2178
2179         if (attrs->ia_valid & ATTR_ATIME)
2180                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2181         else
2182                 args->atime = NO_CHANGE_64;
2183
2184         if (attrs->ia_valid & ATTR_MTIME)
2185                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2186         else
2187                 args->mtime = NO_CHANGE_64;
2188
2189         if (attrs->ia_valid & ATTR_CTIME)
2190                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2191         else
2192                 args->ctime = NO_CHANGE_64;
2193
2194         args->device = 0;
2195         open_file = find_writable_file(cifsInode, true);
2196         if (open_file) {
2197                 u16 nfid = open_file->fid.netfid;
2198                 u32 npid = open_file->pid;
2199                 pTcon = tlink_tcon(open_file->tlink);
2200                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2201                 cifsFileInfo_put(open_file);
2202         } else {
2203                 tlink = cifs_sb_tlink(cifs_sb);
2204                 if (IS_ERR(tlink)) {
2205                         rc = PTR_ERR(tlink);
2206                         goto out;
2207                 }
2208                 pTcon = tlink_tcon(tlink);
2209                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2210                                     cifs_sb->local_nls,
2211                                     cifs_sb->mnt_cifs_flags &
2212                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
2213                 cifs_put_tlink(tlink);
2214         }
2215
2216         if (rc)
2217                 goto out;
2218
2219         if ((attrs->ia_valid & ATTR_SIZE) &&
2220             attrs->ia_size != i_size_read(inode))
2221                 truncate_setsize(inode, attrs->ia_size);
2222
2223         setattr_copy(inode, attrs);
2224         mark_inode_dirty(inode);
2225
2226         /* force revalidate when any of these times are set since some
2227            of the fs types (eg ext3, fat) do not have fine enough
2228            time granularity to match protocol, and we do not have a
2229            a way (yet) to query the server fs's time granularity (and
2230            whether it rounds times down).
2231         */
2232         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2233                 cifsInode->time = 0;
2234 out:
2235         kfree(args);
2236         kfree(full_path);
2237         free_xid(xid);
2238         return rc;
2239 }
2240
2241 static int
2242 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2243 {
2244         unsigned int xid;
2245         kuid_t uid = INVALID_UID;
2246         kgid_t gid = INVALID_GID;
2247         struct inode *inode = direntry->d_inode;
2248         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2249         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2250         char *full_path = NULL;
2251         int rc = -EACCES;
2252         __u32 dosattr = 0;
2253         __u64 mode = NO_CHANGE_64;
2254
2255         xid = get_xid();
2256
2257         cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2258                  direntry, attrs->ia_valid);
2259
2260         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2261                 attrs->ia_valid |= ATTR_FORCE;
2262
2263         rc = inode_change_ok(inode, attrs);
2264         if (rc < 0) {
2265                 free_xid(xid);
2266                 return rc;
2267         }
2268
2269         full_path = build_path_from_dentry(direntry);
2270         if (full_path == NULL) {
2271                 rc = -ENOMEM;
2272                 free_xid(xid);
2273                 return rc;
2274         }
2275
2276         /*
2277          * Attempt to flush data before changing attributes. We need to do
2278          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2279          * ownership or mode then we may also need to do this. Here, we take
2280          * the safe way out and just do the flush on all setattr requests. If
2281          * the flush returns error, store it to report later and continue.
2282          *
2283          * BB: This should be smarter. Why bother flushing pages that
2284          * will be truncated anyway? Also, should we error out here if
2285          * the flush returns error?
2286          */
2287         rc = filemap_write_and_wait(inode->i_mapping);
2288         mapping_set_error(inode->i_mapping, rc);
2289         rc = 0;
2290
2291         if (attrs->ia_valid & ATTR_SIZE) {
2292                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2293                 if (rc != 0)
2294                         goto cifs_setattr_exit;
2295         }
2296
2297         if (attrs->ia_valid & ATTR_UID)
2298                 uid = attrs->ia_uid;
2299
2300         if (attrs->ia_valid & ATTR_GID)
2301                 gid = attrs->ia_gid;
2302
2303 #ifdef CONFIG_CIFS_ACL
2304         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2305                 if (uid_valid(uid) || gid_valid(gid)) {
2306                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2307                                                         uid, gid);
2308                         if (rc) {
2309                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2310                                          __func__, rc);
2311                                 goto cifs_setattr_exit;
2312                         }
2313                 }
2314         } else
2315 #endif /* CONFIG_CIFS_ACL */
2316         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2317                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2318
2319         /* skip mode change if it's just for clearing setuid/setgid */
2320         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2321                 attrs->ia_valid &= ~ATTR_MODE;
2322
2323         if (attrs->ia_valid & ATTR_MODE) {
2324                 mode = attrs->ia_mode;
2325                 rc = 0;
2326 #ifdef CONFIG_CIFS_ACL
2327                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2328                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2329                                                 INVALID_UID, INVALID_GID);
2330                         if (rc) {
2331                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2332                                          __func__, rc);
2333                                 goto cifs_setattr_exit;
2334                         }
2335                 } else
2336 #endif /* CONFIG_CIFS_ACL */
2337                 if (((mode & S_IWUGO) == 0) &&
2338                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2339
2340                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2341
2342                         /* fix up mode if we're not using dynperm */
2343                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2344                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2345                 } else if ((mode & S_IWUGO) &&
2346                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2347
2348                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2349                         /* Attributes of 0 are ignored */
2350                         if (dosattr == 0)
2351                                 dosattr |= ATTR_NORMAL;
2352
2353                         /* reset local inode permissions to normal */
2354                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2355                                 attrs->ia_mode &= ~(S_IALLUGO);
2356                                 if (S_ISDIR(inode->i_mode))
2357                                         attrs->ia_mode |=
2358                                                 cifs_sb->mnt_dir_mode;
2359                                 else
2360                                         attrs->ia_mode |=
2361                                                 cifs_sb->mnt_file_mode;
2362                         }
2363                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2364                         /* ignore mode change - ATTR_READONLY hasn't changed */
2365                         attrs->ia_valid &= ~ATTR_MODE;
2366                 }
2367         }
2368
2369         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2370             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2371                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2372                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2373
2374                 /* Even if error on time set, no sense failing the call if
2375                 the server would set the time to a reasonable value anyway,
2376                 and this check ensures that we are not being called from
2377                 sys_utimes in which case we ought to fail the call back to
2378                 the user when the server rejects the call */
2379                 if ((rc) && (attrs->ia_valid &
2380                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2381                         rc = 0;
2382         }
2383
2384         /* do not need local check to inode_check_ok since the server does
2385            that */
2386         if (rc)
2387                 goto cifs_setattr_exit;
2388
2389         if ((attrs->ia_valid & ATTR_SIZE) &&
2390             attrs->ia_size != i_size_read(inode))
2391                 truncate_setsize(inode, attrs->ia_size);
2392
2393         setattr_copy(inode, attrs);
2394         mark_inode_dirty(inode);
2395
2396 cifs_setattr_exit:
2397         kfree(full_path);
2398         free_xid(xid);
2399         return rc;
2400 }
2401
2402 int
2403 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2404 {
2405         struct inode *inode = direntry->d_inode;
2406         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2407         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2408
2409         if (pTcon->unix_ext)
2410                 return cifs_setattr_unix(direntry, attrs);
2411
2412         return cifs_setattr_nounix(direntry, attrs);
2413
2414         /* BB: add cifs_setattr_legacy for really old servers */
2415 }
2416
2417 #if 0
2418 void cifs_delete_inode(struct inode *inode)
2419 {
2420         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2421         /* may have to add back in if and when safe distributed caching of
2422            directories added e.g. via FindNotify */
2423 }
2424 #endif