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                 if (d_is_dir(target_dentry))
1724                         tmprc = cifs_rmdir(target_dir, target_dentry);
1725                 else
1726                         tmprc = cifs_unlink(target_dir, target_dentry);
1727                 if (tmprc)
1728                         goto cifs_rename_exit;
1729                 rc = cifs_do_rename(xid, source_dentry, from_name,
1730                                     target_dentry, to_name);
1731         }
1732
1733         /* force revalidate to go get info when needed */
1734         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1735
1736         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1737                 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1738
1739 cifs_rename_exit:
1740         kfree(info_buf_source);
1741         kfree(from_name);
1742         kfree(to_name);
1743         free_xid(xid);
1744         cifs_put_tlink(tlink);
1745         return rc;
1746 }
1747
1748 static bool
1749 cifs_inode_needs_reval(struct inode *inode)
1750 {
1751         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1752         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1753
1754         if (CIFS_CACHE_READ(cifs_i))
1755                 return false;
1756
1757         if (!lookupCacheEnabled)
1758                 return true;
1759
1760         if (cifs_i->time == 0)
1761                 return true;
1762
1763         if (!cifs_sb->actimeo)
1764                 return true;
1765
1766         if (!time_in_range(jiffies, cifs_i->time,
1767                                 cifs_i->time + cifs_sb->actimeo))
1768                 return true;
1769
1770         /* hardlinked files w/ noserverino get "special" treatment */
1771         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1772             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1773                 return true;
1774
1775         return false;
1776 }
1777
1778 /*
1779  * Zap the cache. Called when invalid_mapping flag is set.
1780  */
1781 int
1782 cifs_invalidate_mapping(struct inode *inode)
1783 {
1784         int rc = 0;
1785
1786         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1787                 rc = invalidate_inode_pages2(inode->i_mapping);
1788                 if (rc)
1789                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1790                                  __func__, inode);
1791         }
1792
1793         cifs_fscache_reset_inode_cookie(inode);
1794         return rc;
1795 }
1796
1797 /**
1798  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1799  * @word: long word containing the bit lock
1800  */
1801 static int
1802 cifs_wait_bit_killable(struct wait_bit_key *key)
1803 {
1804         if (fatal_signal_pending(current))
1805                 return -ERESTARTSYS;
1806         freezable_schedule_unsafe();
1807         return 0;
1808 }
1809
1810 int
1811 cifs_revalidate_mapping(struct inode *inode)
1812 {
1813         int rc;
1814         unsigned long *flags = &CIFS_I(inode)->flags;
1815
1816         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1817                                      TASK_KILLABLE);
1818         if (rc)
1819                 return rc;
1820
1821         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1822                 rc = cifs_invalidate_mapping(inode);
1823                 if (rc)
1824                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1825         }
1826
1827         clear_bit_unlock(CIFS_INO_LOCK, flags);
1828         smp_mb__after_atomic();
1829         wake_up_bit(flags, CIFS_INO_LOCK);
1830
1831         return rc;
1832 }
1833
1834 int
1835 cifs_zap_mapping(struct inode *inode)
1836 {
1837         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1838         return cifs_revalidate_mapping(inode);
1839 }
1840
1841 int cifs_revalidate_file_attr(struct file *filp)
1842 {
1843         int rc = 0;
1844         struct inode *inode = file_inode(filp);
1845         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1846
1847         if (!cifs_inode_needs_reval(inode))
1848                 return rc;
1849
1850         if (tlink_tcon(cfile->tlink)->unix_ext)
1851                 rc = cifs_get_file_info_unix(filp);
1852         else
1853                 rc = cifs_get_file_info(filp);
1854
1855         return rc;
1856 }
1857
1858 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1859 {
1860         unsigned int xid;
1861         int rc = 0;
1862         struct inode *inode = dentry->d_inode;
1863         struct super_block *sb = dentry->d_sb;
1864         char *full_path = NULL;
1865
1866         if (inode == NULL)
1867                 return -ENOENT;
1868
1869         if (!cifs_inode_needs_reval(inode))
1870                 return rc;
1871
1872         xid = get_xid();
1873
1874         /* can not safely grab the rename sem here if rename calls revalidate
1875            since that would deadlock */
1876         full_path = build_path_from_dentry(dentry);
1877         if (full_path == NULL) {
1878                 rc = -ENOMEM;
1879                 goto out;
1880         }
1881
1882         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1883                  full_path, inode, inode->i_count.counter,
1884                  dentry, dentry->d_time, jiffies);
1885
1886         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1887                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1888         else
1889                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1890                                          xid, NULL);
1891
1892 out:
1893         kfree(full_path);
1894         free_xid(xid);
1895         return rc;
1896 }
1897
1898 int cifs_revalidate_file(struct file *filp)
1899 {
1900         int rc;
1901         struct inode *inode = file_inode(filp);
1902
1903         rc = cifs_revalidate_file_attr(filp);
1904         if (rc)
1905                 return rc;
1906
1907         return cifs_revalidate_mapping(inode);
1908 }
1909
1910 /* revalidate a dentry's inode attributes */
1911 int cifs_revalidate_dentry(struct dentry *dentry)
1912 {
1913         int rc;
1914         struct inode *inode = dentry->d_inode;
1915
1916         rc = cifs_revalidate_dentry_attr(dentry);
1917         if (rc)
1918                 return rc;
1919
1920         return cifs_revalidate_mapping(inode);
1921 }
1922
1923 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1924                  struct kstat *stat)
1925 {
1926         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1927         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1928         struct inode *inode = dentry->d_inode;
1929         int rc;
1930
1931         /*
1932          * We need to be sure that all dirty pages are written and the server
1933          * has actual ctime, mtime and file length.
1934          */
1935         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1936             inode->i_mapping->nrpages != 0) {
1937                 rc = filemap_fdatawait(inode->i_mapping);
1938                 if (rc) {
1939                         mapping_set_error(inode->i_mapping, rc);
1940                         return rc;
1941                 }
1942         }
1943
1944         rc = cifs_revalidate_dentry_attr(dentry);
1945         if (rc)
1946                 return rc;
1947
1948         generic_fillattr(inode, stat);
1949         stat->blksize = CIFS_MAX_MSGSIZE;
1950         stat->ino = CIFS_I(inode)->uniqueid;
1951
1952         /*
1953          * If on a multiuser mount without unix extensions or cifsacl being
1954          * enabled, and the admin hasn't overridden them, set the ownership
1955          * to the fsuid/fsgid of the current process.
1956          */
1957         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1958             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1959             !tcon->unix_ext) {
1960                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1961                         stat->uid = current_fsuid();
1962                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1963                         stat->gid = current_fsgid();
1964         }
1965         return rc;
1966 }
1967
1968 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1969 {
1970         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1971         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1972         struct page *page;
1973         int rc = 0;
1974
1975         page = grab_cache_page(mapping, index);
1976         if (!page)
1977                 return -ENOMEM;
1978
1979         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1980         unlock_page(page);
1981         page_cache_release(page);
1982         return rc;
1983 }
1984
1985 static void cifs_setsize(struct inode *inode, loff_t offset)
1986 {
1987         spin_lock(&inode->i_lock);
1988         i_size_write(inode, offset);
1989         spin_unlock(&inode->i_lock);
1990
1991         truncate_pagecache(inode, offset);
1992 }
1993
1994 static int
1995 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1996                    unsigned int xid, char *full_path)
1997 {
1998         int rc;
1999         struct cifsFileInfo *open_file;
2000         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2001         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2002         struct tcon_link *tlink = NULL;
2003         struct cifs_tcon *tcon = NULL;
2004         struct TCP_Server_Info *server;
2005         struct cifs_io_parms io_parms;
2006
2007         /*
2008          * To avoid spurious oplock breaks from server, in the case of
2009          * inodes that we already have open, avoid doing path based
2010          * setting of file size if we can do it by handle.
2011          * This keeps our caching token (oplock) and avoids timeouts
2012          * when the local oplock break takes longer to flush
2013          * writebehind data than the SMB timeout for the SetPathInfo
2014          * request would allow
2015          */
2016         open_file = find_writable_file(cifsInode, true);
2017         if (open_file) {
2018                 tcon = tlink_tcon(open_file->tlink);
2019                 server = tcon->ses->server;
2020                 if (server->ops->set_file_size)
2021                         rc = server->ops->set_file_size(xid, tcon, open_file,
2022                                                         attrs->ia_size, false);
2023                 else
2024                         rc = -ENOSYS;
2025                 cifsFileInfo_put(open_file);
2026                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2027                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2028                         unsigned int bytes_written;
2029
2030                         io_parms.netfid = open_file->fid.netfid;
2031                         io_parms.pid = open_file->pid;
2032                         io_parms.tcon = tcon;
2033                         io_parms.offset = 0;
2034                         io_parms.length = attrs->ia_size;
2035                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
2036                                           NULL, NULL, 1);
2037                         cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
2038                 }
2039         } else
2040                 rc = -EINVAL;
2041
2042         if (!rc)
2043                 goto set_size_out;
2044
2045         if (tcon == NULL) {
2046                 tlink = cifs_sb_tlink(cifs_sb);
2047                 if (IS_ERR(tlink))
2048                         return PTR_ERR(tlink);
2049                 tcon = tlink_tcon(tlink);
2050                 server = tcon->ses->server;
2051         }
2052
2053         /*
2054          * Set file size by pathname rather than by handle either because no
2055          * valid, writeable file handle for it was found or because there was
2056          * an error setting it by handle.
2057          */
2058         if (server->ops->set_path_size)
2059                 rc = server->ops->set_path_size(xid, tcon, full_path,
2060                                                 attrs->ia_size, cifs_sb, false);
2061         else
2062                 rc = -ENOSYS;
2063         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2064         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2065                 __u16 netfid;
2066                 int oplock = 0;
2067
2068                 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
2069                                    GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
2070                                    &oplock, NULL, cifs_sb->local_nls,
2071                                    cifs_sb->mnt_cifs_flags &
2072                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2073                 if (rc == 0) {
2074                         unsigned int bytes_written;
2075
2076                         io_parms.netfid = netfid;
2077                         io_parms.pid = current->tgid;
2078                         io_parms.tcon = tcon;
2079                         io_parms.offset = 0;
2080                         io_parms.length = attrs->ia_size;
2081                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
2082                                           NULL,  1);
2083                         cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
2084                         CIFSSMBClose(xid, tcon, netfid);
2085                 }
2086         }
2087         if (tlink)
2088                 cifs_put_tlink(tlink);
2089
2090 set_size_out:
2091         if (rc == 0) {
2092                 cifsInode->server_eof = attrs->ia_size;
2093                 cifs_setsize(inode, attrs->ia_size);
2094                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2095         }
2096
2097         return rc;
2098 }
2099
2100 static int
2101 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2102 {
2103         int rc;
2104         unsigned int xid;
2105         char *full_path = NULL;
2106         struct inode *inode = direntry->d_inode;
2107         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2108         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2109         struct tcon_link *tlink;
2110         struct cifs_tcon *pTcon;
2111         struct cifs_unix_set_info_args *args = NULL;
2112         struct cifsFileInfo *open_file;
2113
2114         cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2115                  direntry->d_name.name, attrs->ia_valid);
2116
2117         xid = get_xid();
2118
2119         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2120                 attrs->ia_valid |= ATTR_FORCE;
2121
2122         rc = inode_change_ok(inode, attrs);
2123         if (rc < 0)
2124                 goto out;
2125
2126         full_path = build_path_from_dentry(direntry);
2127         if (full_path == NULL) {
2128                 rc = -ENOMEM;
2129                 goto out;
2130         }
2131
2132         /*
2133          * Attempt to flush data before changing attributes. We need to do
2134          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2135          * ownership or mode then we may also need to do this. Here, we take
2136          * the safe way out and just do the flush on all setattr requests. If
2137          * the flush returns error, store it to report later and continue.
2138          *
2139          * BB: This should be smarter. Why bother flushing pages that
2140          * will be truncated anyway? Also, should we error out here if
2141          * the flush returns error?
2142          */
2143         rc = filemap_write_and_wait(inode->i_mapping);
2144         mapping_set_error(inode->i_mapping, rc);
2145         rc = 0;
2146
2147         if (attrs->ia_valid & ATTR_SIZE) {
2148                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2149                 if (rc != 0)
2150                         goto out;
2151         }
2152
2153         /* skip mode change if it's just for clearing setuid/setgid */
2154         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2155                 attrs->ia_valid &= ~ATTR_MODE;
2156
2157         args = kmalloc(sizeof(*args), GFP_KERNEL);
2158         if (args == NULL) {
2159                 rc = -ENOMEM;
2160                 goto out;
2161         }
2162
2163         /* set up the struct */
2164         if (attrs->ia_valid & ATTR_MODE)
2165                 args->mode = attrs->ia_mode;
2166         else
2167                 args->mode = NO_CHANGE_64;
2168
2169         if (attrs->ia_valid & ATTR_UID)
2170                 args->uid = attrs->ia_uid;
2171         else
2172                 args->uid = INVALID_UID; /* no change */
2173
2174         if (attrs->ia_valid & ATTR_GID)
2175                 args->gid = attrs->ia_gid;
2176         else
2177                 args->gid = INVALID_GID; /* no change */
2178
2179         if (attrs->ia_valid & ATTR_ATIME)
2180                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2181         else
2182                 args->atime = NO_CHANGE_64;
2183
2184         if (attrs->ia_valid & ATTR_MTIME)
2185                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2186         else
2187                 args->mtime = NO_CHANGE_64;
2188
2189         if (attrs->ia_valid & ATTR_CTIME)
2190                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2191         else
2192                 args->ctime = NO_CHANGE_64;
2193
2194         args->device = 0;
2195         open_file = find_writable_file(cifsInode, true);
2196         if (open_file) {
2197                 u16 nfid = open_file->fid.netfid;
2198                 u32 npid = open_file->pid;
2199                 pTcon = tlink_tcon(open_file->tlink);
2200                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2201                 cifsFileInfo_put(open_file);
2202         } else {
2203                 tlink = cifs_sb_tlink(cifs_sb);
2204                 if (IS_ERR(tlink)) {
2205                         rc = PTR_ERR(tlink);
2206                         goto out;
2207                 }
2208                 pTcon = tlink_tcon(tlink);
2209                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2210                                     cifs_sb->local_nls,
2211                                     cifs_sb->mnt_cifs_flags &
2212                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
2213                 cifs_put_tlink(tlink);
2214         }
2215
2216         if (rc)
2217                 goto out;
2218
2219         if ((attrs->ia_valid & ATTR_SIZE) &&
2220             attrs->ia_size != i_size_read(inode))
2221                 truncate_setsize(inode, attrs->ia_size);
2222
2223         setattr_copy(inode, attrs);
2224         mark_inode_dirty(inode);
2225
2226         /* force revalidate when any of these times are set since some
2227            of the fs types (eg ext3, fat) do not have fine enough
2228            time granularity to match protocol, and we do not have a
2229            a way (yet) to query the server fs's time granularity (and
2230            whether it rounds times down).
2231         */
2232         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2233                 cifsInode->time = 0;
2234 out:
2235         kfree(args);
2236         kfree(full_path);
2237         free_xid(xid);
2238         return rc;
2239 }
2240
2241 static int
2242 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2243 {
2244         unsigned int xid;
2245         kuid_t uid = INVALID_UID;
2246         kgid_t gid = INVALID_GID;
2247         struct inode *inode = direntry->d_inode;
2248         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2249         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2250         char *full_path = NULL;
2251         int rc = -EACCES;
2252         __u32 dosattr = 0;
2253         __u64 mode = NO_CHANGE_64;
2254
2255         xid = get_xid();
2256
2257         cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2258                  direntry->d_name.name, attrs->ia_valid);
2259
2260         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2261                 attrs->ia_valid |= ATTR_FORCE;
2262
2263         rc = inode_change_ok(inode, attrs);
2264         if (rc < 0) {
2265                 free_xid(xid);
2266                 return rc;
2267         }
2268
2269         full_path = build_path_from_dentry(direntry);
2270         if (full_path == NULL) {
2271                 rc = -ENOMEM;
2272                 free_xid(xid);
2273                 return rc;
2274         }
2275
2276         /*
2277          * Attempt to flush data before changing attributes. We need to do
2278          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2279          * ownership or mode then we may also need to do this. Here, we take
2280          * the safe way out and just do the flush on all setattr requests. If
2281          * the flush returns error, store it to report later and continue.
2282          *
2283          * BB: This should be smarter. Why bother flushing pages that
2284          * will be truncated anyway? Also, should we error out here if
2285          * the flush returns error?
2286          */
2287         rc = filemap_write_and_wait(inode->i_mapping);
2288         mapping_set_error(inode->i_mapping, rc);
2289         rc = 0;
2290
2291         if (attrs->ia_valid & ATTR_SIZE) {
2292                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2293                 if (rc != 0)
2294                         goto cifs_setattr_exit;
2295         }
2296
2297         if (attrs->ia_valid & ATTR_UID)
2298                 uid = attrs->ia_uid;
2299
2300         if (attrs->ia_valid & ATTR_GID)
2301                 gid = attrs->ia_gid;
2302
2303 #ifdef CONFIG_CIFS_ACL
2304         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2305                 if (uid_valid(uid) || gid_valid(gid)) {
2306                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2307                                                         uid, gid);
2308                         if (rc) {
2309                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2310                                          __func__, rc);
2311                                 goto cifs_setattr_exit;
2312                         }
2313                 }
2314         } else
2315 #endif /* CONFIG_CIFS_ACL */
2316         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2317                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2318
2319         /* skip mode change if it's just for clearing setuid/setgid */
2320         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2321                 attrs->ia_valid &= ~ATTR_MODE;
2322
2323         if (attrs->ia_valid & ATTR_MODE) {
2324                 mode = attrs->ia_mode;
2325                 rc = 0;
2326 #ifdef CONFIG_CIFS_ACL
2327                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2328                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2329                                                 INVALID_UID, INVALID_GID);
2330                         if (rc) {
2331                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2332                                          __func__, rc);
2333                                 goto cifs_setattr_exit;
2334                         }
2335                 } else
2336 #endif /* CONFIG_CIFS_ACL */
2337                 if (((mode & S_IWUGO) == 0) &&
2338                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2339
2340                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2341
2342                         /* fix up mode if we're not using dynperm */
2343                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2344                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2345                 } else if ((mode & S_IWUGO) &&
2346                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2347
2348                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2349                         /* Attributes of 0 are ignored */
2350                         if (dosattr == 0)
2351                                 dosattr |= ATTR_NORMAL;
2352
2353                         /* reset local inode permissions to normal */
2354                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2355                                 attrs->ia_mode &= ~(S_IALLUGO);
2356                                 if (S_ISDIR(inode->i_mode))
2357                                         attrs->ia_mode |=
2358                                                 cifs_sb->mnt_dir_mode;
2359                                 else
2360                                         attrs->ia_mode |=
2361                                                 cifs_sb->mnt_file_mode;
2362                         }
2363                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2364                         /* ignore mode change - ATTR_READONLY hasn't changed */
2365                         attrs->ia_valid &= ~ATTR_MODE;
2366                 }
2367         }
2368
2369         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2370             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2371                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2372                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2373
2374                 /* Even if error on time set, no sense failing the call if
2375                 the server would set the time to a reasonable value anyway,
2376                 and this check ensures that we are not being called from
2377                 sys_utimes in which case we ought to fail the call back to
2378                 the user when the server rejects the call */
2379                 if ((rc) && (attrs->ia_valid &
2380                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2381                         rc = 0;
2382         }
2383
2384         /* do not need local check to inode_check_ok since the server does
2385            that */
2386         if (rc)
2387                 goto cifs_setattr_exit;
2388
2389         if ((attrs->ia_valid & ATTR_SIZE) &&
2390             attrs->ia_size != i_size_read(inode))
2391                 truncate_setsize(inode, attrs->ia_size);
2392
2393         setattr_copy(inode, attrs);
2394         mark_inode_dirty(inode);
2395
2396 cifs_setattr_exit:
2397         kfree(full_path);
2398         free_xid(xid);
2399         return rc;
2400 }
2401
2402 int
2403 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2404 {
2405         struct inode *inode = direntry->d_inode;
2406         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2407         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2408
2409         if (pTcon->unix_ext)
2410                 return cifs_setattr_unix(direntry, attrs);
2411
2412         return cifs_setattr_nounix(direntry, attrs);
2413
2414         /* BB: add cifs_setattr_legacy for really old servers */
2415 }
2416
2417 #if 0
2418 void cifs_delete_inode(struct inode *inode)
2419 {
2420         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2421         /* may have to add back in if and when safe distributed caching of
2422            directories added e.g. via FindNotify */
2423 }
2424 #endif