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