fs/cifs/inode.c

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