fs/cifs/inode.c

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