kernel/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         char *path = NULL;
 986         int len;
 987
 988         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
 989             && cifs_sb->prepath) {
 990                 len = strlen(cifs_sb->prepath);
 991                 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
 992                 if (path == NULL)
 993                         return ERR_PTR(-ENOMEM);
 994                 path[0] = '/';
 995                 memcpy(path+1, cifs_sb->prepath, len);
 996         } else {
 997                 path = kstrdup("", GFP_KERNEL);
 998                 if (path == NULL)
 999                         return ERR_PTR(-ENOMEM);
1000         }
1001
1002         xid = get_xid();
1003         if (tcon->unix_ext) {
1004                 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1005                 /* some servers mistakenly claim POSIX support */
1006                 if (rc != -EOPNOTSUPP)
1007                         goto iget_no_retry;
1008                 cifs_dbg(VFS, "server does not support POSIX extensions");
1009                 tcon->unix_ext = false;
1010         }
1011
1012         convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1013         rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1014
1015 iget_no_retry:
1016         if (!inode) {
1017                 inode = ERR_PTR(rc);
1018                 goto out;
1019         }
1020
1021 #ifdef CONFIG_CIFS_FSCACHE
1022         /* populate tcon->resource_id */
1023         tcon->resource_id = CIFS_I(inode)->uniqueid;
1024 #endif
1025
1026         if (rc && tcon->ipc) {
1027                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1028                 spin_lock(&inode->i_lock);
1029                 inode->i_mode |= S_IFDIR;
1030                 set_nlink(inode, 2);
1031                 inode->i_op = &cifs_ipc_inode_ops;
1032                 inode->i_fop = &simple_dir_operations;
1033                 inode->i_uid = cifs_sb->mnt_uid;
1034                 inode->i_gid = cifs_sb->mnt_gid;
1035                 spin_unlock(&inode->i_lock);
1036         } else if (rc) {
1037                 iget_failed(inode);
1038                 inode = ERR_PTR(rc);
1039         }
1040
1041 out:
1042         kfree(path);
1043         /* can not call macro free_xid here since in a void func
1044          * TODO: This is no longer true
1045          */
1046         _free_xid(xid);
1047         return inode;
1048 }
1049
1050 int
1051 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1052                    char *full_path, __u32 dosattr)
1053 {
1054         bool set_time = false;
1055         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1056         struct TCP_Server_Info *server;
1057         FILE_BASIC_INFO info_buf;
1058
1059         if (attrs == NULL)
1060                 return -EINVAL;
1061
1062         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1063         if (!server->ops->set_file_info)
1064                 return -ENOSYS;
1065
1066         if (attrs->ia_valid & ATTR_ATIME) {
1067                 set_time = true;
1068                 info_buf.LastAccessTime =
1069                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1070         } else
1071                 info_buf.LastAccessTime = 0;
1072
1073         if (attrs->ia_valid & ATTR_MTIME) {
1074                 set_time = true;
1075                 info_buf.LastWriteTime =
1076                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1077         } else
1078                 info_buf.LastWriteTime = 0;
1079
1080         /*
1081          * Samba throws this field away, but windows may actually use it.
1082          * Do not set ctime unless other time stamps are changed explicitly
1083          * (i.e. by utimes()) since we would then have a mix of client and
1084          * server times.
1085          */
1086         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1087                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1088                 info_buf.ChangeTime =
1089                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1090         } else
1091                 info_buf.ChangeTime = 0;
1092
1093         info_buf.CreationTime = 0;      /* don't change */
1094         info_buf.Attributes = cpu_to_le32(dosattr);
1095
1096         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1097 }
1098
1099 /*
1100  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1101  * and rename it to a random name that hopefully won't conflict with
1102  * anything else.
1103  */
1104 int
1105 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1106                            const unsigned int xid)
1107 {
1108         int oplock = 0;
1109         int rc;
1110         struct cifs_fid fid;
1111         struct cifs_open_parms oparms;
1112         struct inode *inode = d_inode(dentry);
1113         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1114         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1115         struct tcon_link *tlink;
1116         struct cifs_tcon *tcon;
1117         __u32 dosattr, origattr;
1118         FILE_BASIC_INFO *info_buf = NULL;
1119
1120         tlink = cifs_sb_tlink(cifs_sb);
1121         if (IS_ERR(tlink))
1122                 return PTR_ERR(tlink);
1123         tcon = tlink_tcon(tlink);
1124
1125         /*
1126          * We cannot rename the file if the server doesn't support
1127          * CAP_INFOLEVEL_PASSTHRU
1128          */
1129         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1130                 rc = -EBUSY;
1131                 goto out;
1132         }
1133
1134         oparms.tcon = tcon;
1135         oparms.cifs_sb = cifs_sb;
1136         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1137         oparms.create_options = CREATE_NOT_DIR;
1138         oparms.disposition = FILE_OPEN;
1139         oparms.path = full_path;
1140         oparms.fid = &fid;
1141         oparms.reconnect = false;
1142
1143         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1144         if (rc != 0)
1145                 goto out;
1146
1147         origattr = cifsInode->cifsAttrs;
1148         if (origattr == 0)
1149                 origattr |= ATTR_NORMAL;
1150
1151         dosattr = origattr & ~ATTR_READONLY;
1152         if (dosattr == 0)
1153                 dosattr |= ATTR_NORMAL;
1154         dosattr |= ATTR_HIDDEN;
1155
1156         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1157         if (dosattr != origattr) {
1158                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1159                 if (info_buf == NULL) {
1160                         rc = -ENOMEM;
1161                         goto out_close;
1162                 }
1163                 info_buf->Attributes = cpu_to_le32(dosattr);
1164                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1165                                         current->tgid);
1166                 /* although we would like to mark the file hidden
1167                    if that fails we will still try to rename it */
1168                 if (!rc)
1169                         cifsInode->cifsAttrs = dosattr;
1170                 else
1171                         dosattr = origattr; /* since not able to change them */
1172         }
1173
1174         /* rename the file */
1175         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1176                                    cifs_sb->local_nls,
1177                                    cifs_remap(cifs_sb));
1178         if (rc != 0) {
1179                 rc = -EBUSY;
1180                 goto undo_setattr;
1181         }
1182
1183         /* try to set DELETE_ON_CLOSE */
1184         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1185                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1186                                                current->tgid);
1187                 /*
1188                  * some samba versions return -ENOENT when we try to set the
1189                  * file disposition here. Likely a samba bug, but work around
1190                  * it for now. This means that some cifsXXX files may hang
1191                  * around after they shouldn't.
1192                  *
1193                  * BB: remove this hack after more servers have the fix
1194                  */
1195                 if (rc == -ENOENT)
1196                         rc = 0;
1197                 else if (rc != 0) {
1198                         rc = -EBUSY;
1199                         goto undo_rename;
1200                 }
1201                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1202         }
1203
1204 out_close:
1205         CIFSSMBClose(xid, tcon, fid.netfid);
1206 out:
1207         kfree(info_buf);
1208         cifs_put_tlink(tlink);
1209         return rc;
1210
1211         /*
1212          * reset everything back to the original state. Don't bother
1213          * dealing with errors here since we can't do anything about
1214          * them anyway.
1215          */
1216 undo_rename:
1217         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1218                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1219 undo_setattr:
1220         if (dosattr != origattr) {
1221                 info_buf->Attributes = cpu_to_le32(origattr);
1222                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1223                                         current->tgid))
1224                         cifsInode->cifsAttrs = origattr;
1225         }
1226
1227         goto out_close;
1228 }
1229
1230 /* copied from fs/nfs/dir.c with small changes */
1231 static void
1232 cifs_drop_nlink(struct inode *inode)
1233 {
1234         spin_lock(&inode->i_lock);
1235         if (inode->i_nlink > 0)
1236                 drop_nlink(inode);
1237         spin_unlock(&inode->i_lock);
1238 }
1239
1240 /*
1241  * If d_inode(dentry) is null (usually meaning the cached dentry
1242  * is a negative dentry) then we would attempt a standard SMB delete, but
1243  * if that fails we can not attempt the fall back mechanisms on EACCESS
1244  * but will return the EACCESS to the caller. Note that the VFS does not call
1245  * unlink on negative dentries currently.
1246  */
1247 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1248 {
1249         int rc = 0;
1250         unsigned int xid;
1251         char *full_path = NULL;
1252         struct inode *inode = d_inode(dentry);
1253         struct cifsInodeInfo *cifs_inode;
1254         struct super_block *sb = dir->i_sb;
1255         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1256         struct tcon_link *tlink;
1257         struct cifs_tcon *tcon;
1258         struct TCP_Server_Info *server;
1259         struct iattr *attrs = NULL;
1260         __u32 dosattr = 0, origattr = 0;
1261
1262         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1263
1264         tlink = cifs_sb_tlink(cifs_sb);
1265         if (IS_ERR(tlink))
1266                 return PTR_ERR(tlink);
1267         tcon = tlink_tcon(tlink);
1268         server = tcon->ses->server;
1269
1270         xid = get_xid();
1271
1272         /* Unlink can be called from rename so we can not take the
1273          * sb->s_vfs_rename_mutex here */
1274         full_path = build_path_from_dentry(dentry);
1275         if (full_path == NULL) {
1276                 rc = -ENOMEM;
1277                 goto unlink_out;
1278         }
1279
1280         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1281                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1282                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1283                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1284                         cifs_remap(cifs_sb));
1285                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1286                 if ((rc == 0) || (rc == -ENOENT))
1287                         goto psx_del_no_retry;
1288         }
1289
1290 retry_std_delete:
1291         if (!server->ops->unlink) {
1292                 rc = -ENOSYS;
1293                 goto psx_del_no_retry;
1294         }
1295
1296         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1297
1298 psx_del_no_retry:
1299         if (!rc) {
1300                 if (inode)
1301                         cifs_drop_nlink(inode);
1302         } else if (rc == -ENOENT) {
1303                 d_drop(dentry);
1304         } else if (rc == -EBUSY) {
1305                 if (server->ops->rename_pending_delete) {
1306                         rc = server->ops->rename_pending_delete(full_path,
1307                                                                 dentry, xid);
1308                         if (rc == 0)
1309                                 cifs_drop_nlink(inode);
1310                 }
1311         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1312                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1313                 if (attrs == NULL) {
1314                         rc = -ENOMEM;
1315                         goto out_reval;
1316                 }
1317
1318                 /* try to reset dos attributes */
1319                 cifs_inode = CIFS_I(inode);
1320                 origattr = cifs_inode->cifsAttrs;
1321                 if (origattr == 0)
1322                         origattr |= ATTR_NORMAL;
1323                 dosattr = origattr & ~ATTR_READONLY;
1324                 if (dosattr == 0)
1325                         dosattr |= ATTR_NORMAL;
1326                 dosattr |= ATTR_HIDDEN;
1327
1328                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1329                 if (rc != 0)
1330                         goto out_reval;
1331
1332                 goto retry_std_delete;
1333         }
1334
1335         /* undo the setattr if we errored out and it's needed */
1336         if (rc != 0 && dosattr != 0)
1337                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1338
1339 out_reval:
1340         if (inode) {
1341                 cifs_inode = CIFS_I(inode);
1342                 cifs_inode->time = 0;   /* will force revalidate to get info
1343                                            when needed */
1344                 inode->i_ctime = current_fs_time(sb);
1345         }
1346         dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1347         cifs_inode = CIFS_I(dir);
1348         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1349 unlink_out:
1350         kfree(full_path);
1351         kfree(attrs);
1352         free_xid(xid);
1353         cifs_put_tlink(tlink);
1354         return rc;
1355 }
1356
1357 static int
1358 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1359                  const char *full_path, struct cifs_sb_info *cifs_sb,
1360                  struct cifs_tcon *tcon, const unsigned int xid)
1361 {
1362         int rc = 0;
1363         struct inode *inode = NULL;
1364
1365         if (tcon->unix_ext)
1366                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1367                                               xid);
1368         else
1369                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1370                                          xid, NULL);
1371
1372         if (rc)
1373                 return rc;
1374
1375         /*
1376          * setting nlink not necessary except in cases where we failed to get it
1377          * from the server or was set bogus. Also, since this is a brand new
1378          * inode, no need to grab the i_lock before setting the i_nlink.
1379          */
1380         if (inode->i_nlink < 2)
1381                 set_nlink(inode, 2);
1382         mode &= ~current_umask();
1383         /* must turn on setgid bit if parent dir has it */
1384         if (parent->i_mode & S_ISGID)
1385                 mode |= S_ISGID;
1386
1387         if (tcon->unix_ext) {
1388                 struct cifs_unix_set_info_args args = {
1389                         .mode   = mode,
1390                         .ctime  = NO_CHANGE_64,
1391                         .atime  = NO_CHANGE_64,
1392                         .mtime  = NO_CHANGE_64,
1393                         .device = 0,
1394                 };
1395                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1396                         args.uid = current_fsuid();
1397                         if (parent->i_mode & S_ISGID)
1398                                 args.gid = parent->i_gid;
1399                         else
1400                                 args.gid = current_fsgid();
1401                 } else {
1402                         args.uid = INVALID_UID; /* no change */
1403                         args.gid = INVALID_GID; /* no change */
1404                 }
1405                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1406                                        cifs_sb->local_nls,
1407                                        cifs_remap(cifs_sb));
1408         } else {
1409                 struct TCP_Server_Info *server = tcon->ses->server;
1410                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1411                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1412                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1413                                                    tcon, xid);
1414                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1415                         inode->i_mode = (mode | S_IFDIR);
1416
1417                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1418                         inode->i_uid = current_fsuid();
1419                         if (inode->i_mode & S_ISGID)
1420                                 inode->i_gid = parent->i_gid;
1421                         else
1422                                 inode->i_gid = current_fsgid();
1423                 }
1424         }
1425         d_instantiate(dentry, inode);
1426         return rc;
1427 }
1428
1429 static int
1430 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1431                  const char *full_path, struct cifs_sb_info *cifs_sb,
1432                  struct cifs_tcon *tcon, const unsigned int xid)
1433 {
1434         int rc = 0;
1435         u32 oplock = 0;
1436         FILE_UNIX_BASIC_INFO *info = NULL;
1437         struct inode *newinode = NULL;
1438         struct cifs_fattr fattr;
1439
1440         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1441         if (info == NULL) {
1442                 rc = -ENOMEM;
1443                 goto posix_mkdir_out;
1444         }
1445
1446         mode &= ~current_umask();
1447         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1448                              NULL /* netfid */, info, &oplock, full_path,
1449                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1450         if (rc == -EOPNOTSUPP)
1451                 goto posix_mkdir_out;
1452         else if (rc) {
1453                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1454                 d_drop(dentry);
1455                 goto posix_mkdir_out;
1456         }
1457
1458         if (info->Type == cpu_to_le32(-1))
1459                 /* no return info, go query for it */
1460                 goto posix_mkdir_get_info;
1461         /*
1462          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1463          * need to set uid/gid.
1464          */
1465
1466         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1467         cifs_fill_uniqueid(inode->i_sb, &fattr);
1468         newinode = cifs_iget(inode->i_sb, &fattr);
1469         if (!newinode)
1470                 goto posix_mkdir_get_info;
1471
1472         d_instantiate(dentry, newinode);
1473
1474 #ifdef CONFIG_CIFS_DEBUG2
1475         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1476                  dentry, dentry, newinode);
1477
1478         if (newinode->i_nlink != 2)
1479                 cifs_dbg(FYI, "unexpected number of links %d\n",
1480                          newinode->i_nlink);
1481 #endif
1482
1483 posix_mkdir_out:
1484         kfree(info);
1485         return rc;
1486 posix_mkdir_get_info:
1487         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1488                               xid);
1489         goto posix_mkdir_out;
1490 }
1491
1492 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1493 {
1494         int rc = 0;
1495         unsigned int xid;
1496         struct cifs_sb_info *cifs_sb;
1497         struct tcon_link *tlink;
1498         struct cifs_tcon *tcon;
1499         struct TCP_Server_Info *server;
1500         char *full_path;
1501
1502         cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1503                  mode, inode);
1504
1505         cifs_sb = CIFS_SB(inode->i_sb);
1506         tlink = cifs_sb_tlink(cifs_sb);
1507         if (IS_ERR(tlink))
1508                 return PTR_ERR(tlink);
1509         tcon = tlink_tcon(tlink);
1510
1511         xid = get_xid();
1512
1513         full_path = build_path_from_dentry(direntry);
1514         if (full_path == NULL) {
1515                 rc = -ENOMEM;
1516                 goto mkdir_out;
1517         }
1518
1519         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1520                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1521                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1522                                       tcon, xid);
1523                 if (rc != -EOPNOTSUPP)
1524                         goto mkdir_out;
1525         }
1526
1527         server = tcon->ses->server;
1528
1529         if (!server->ops->mkdir) {
1530                 rc = -ENOSYS;
1531                 goto mkdir_out;
1532         }
1533
1534         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1535         rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1536         if (rc) {
1537                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1538                 d_drop(direntry);
1539                 goto mkdir_out;
1540         }
1541
1542         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1543                               xid);
1544 mkdir_out:
1545         /*
1546          * Force revalidate to get parent dir info when needed since cached
1547          * attributes are invalid now.
1548          */
1549         CIFS_I(inode)->time = 0;
1550         kfree(full_path);
1551         free_xid(xid);
1552         cifs_put_tlink(tlink);
1553         return rc;
1554 }
1555
1556 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1557 {
1558         int rc = 0;
1559         unsigned int xid;
1560         struct cifs_sb_info *cifs_sb;
1561         struct tcon_link *tlink;
1562         struct cifs_tcon *tcon;
1563         struct TCP_Server_Info *server;
1564         char *full_path = NULL;
1565         struct cifsInodeInfo *cifsInode;
1566
1567         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1568
1569         xid = get_xid();
1570
1571         full_path = build_path_from_dentry(direntry);
1572         if (full_path == NULL) {
1573                 rc = -ENOMEM;
1574                 goto rmdir_exit;
1575         }
1576
1577         cifs_sb = CIFS_SB(inode->i_sb);
1578         tlink = cifs_sb_tlink(cifs_sb);
1579         if (IS_ERR(tlink)) {
1580                 rc = PTR_ERR(tlink);
1581                 goto rmdir_exit;
1582         }
1583         tcon = tlink_tcon(tlink);
1584         server = tcon->ses->server;
1585
1586         if (!server->ops->rmdir) {
1587                 rc = -ENOSYS;
1588                 cifs_put_tlink(tlink);
1589                 goto rmdir_exit;
1590         }
1591
1592         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1593         cifs_put_tlink(tlink);
1594
1595         if (!rc) {
1596                 spin_lock(&d_inode(direntry)->i_lock);
1597                 i_size_write(d_inode(direntry), 0);
1598                 clear_nlink(d_inode(direntry));
1599                 spin_unlock(&d_inode(direntry)->i_lock);
1600         }
1601
1602         cifsInode = CIFS_I(d_inode(direntry));
1603         /* force revalidate to go get info when needed */
1604         cifsInode->time = 0;
1605
1606         cifsInode = CIFS_I(inode);
1607         /*
1608          * Force revalidate to get parent dir info when needed since cached
1609          * attributes are invalid now.
1610          */
1611         cifsInode->time = 0;
1612
1613         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1614                 current_fs_time(inode->i_sb);
1615
1616 rmdir_exit:
1617         kfree(full_path);
1618         free_xid(xid);
1619         return rc;
1620 }
1621
1622 static int
1623 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1624                const char *from_path, struct dentry *to_dentry,
1625                const char *to_path)
1626 {
1627         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1628         struct tcon_link *tlink;
1629         struct cifs_tcon *tcon;
1630         struct TCP_Server_Info *server;
1631         struct cifs_fid fid;
1632         struct cifs_open_parms oparms;
1633         int oplock, rc;
1634
1635         tlink = cifs_sb_tlink(cifs_sb);
1636         if (IS_ERR(tlink))
1637                 return PTR_ERR(tlink);
1638         tcon = tlink_tcon(tlink);
1639         server = tcon->ses->server;
1640
1641         if (!server->ops->rename)
1642                 return -ENOSYS;
1643
1644         /* try path-based rename first */
1645         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1646
1647         /*
1648          * Don't bother with rename by filehandle unless file is busy and
1649          * source. Note that cross directory moves do not work with
1650          * rename by filehandle to various Windows servers.
1651          */
1652         if (rc == 0 || rc != -EBUSY)
1653                 goto do_rename_exit;
1654
1655         /* open-file renames don't work across directories */
1656         if (to_dentry->d_parent != from_dentry->d_parent)
1657                 goto do_rename_exit;
1658
1659         oparms.tcon = tcon;
1660         oparms.cifs_sb = cifs_sb;
1661         /* open the file to be renamed -- we need DELETE perms */
1662         oparms.desired_access = DELETE;
1663         oparms.create_options = CREATE_NOT_DIR;
1664         oparms.disposition = FILE_OPEN;
1665         oparms.path = from_path;
1666         oparms.fid = &fid;
1667         oparms.reconnect = false;
1668
1669         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1670         if (rc == 0) {
1671                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1672                                 (const char *) to_dentry->d_name.name,
1673                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1674                 CIFSSMBClose(xid, tcon, fid.netfid);
1675         }
1676 do_rename_exit:
1677         cifs_put_tlink(tlink);
1678         return rc;
1679 }
1680
1681 int
1682 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1683              struct inode *target_dir, struct dentry *target_dentry,
1684              unsigned int flags)
1685 {
1686         char *from_name = NULL;
1687         char *to_name = NULL;
1688         struct cifs_sb_info *cifs_sb;
1689         struct tcon_link *tlink;
1690         struct cifs_tcon *tcon;
1691         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1692         FILE_UNIX_BASIC_INFO *info_buf_target;
1693         unsigned int xid;
1694         int rc, tmprc;
1695
1696         if (flags & ~RENAME_NOREPLACE)
1697                 return -EINVAL;
1698
1699         cifs_sb = CIFS_SB(source_dir->i_sb);
1700         tlink = cifs_sb_tlink(cifs_sb);
1701         if (IS_ERR(tlink))
1702                 return PTR_ERR(tlink);
1703         tcon = tlink_tcon(tlink);
1704
1705         xid = get_xid();
1706
1707         /*
1708          * we already have the rename sem so we do not need to
1709          * grab it again here to protect the path integrity
1710          */
1711         from_name = build_path_from_dentry(source_dentry);
1712         if (from_name == NULL) {
1713                 rc = -ENOMEM;
1714                 goto cifs_rename_exit;
1715         }
1716
1717         to_name = build_path_from_dentry(target_dentry);
1718         if (to_name == NULL) {
1719                 rc = -ENOMEM;
1720                 goto cifs_rename_exit;
1721         }
1722
1723         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1724                             to_name);
1725
1726         /*
1727          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1728          */
1729         if (flags & RENAME_NOREPLACE)
1730                 goto cifs_rename_exit;
1731
1732         if (rc == -EEXIST && tcon->unix_ext) {
1733                 /*
1734                  * Are src and dst hardlinks of same inode? We can only tell
1735                  * with unix extensions enabled.
1736                  */
1737                 info_buf_source =
1738                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1739                                         GFP_KERNEL);
1740                 if (info_buf_source == NULL) {
1741                         rc = -ENOMEM;
1742                         goto cifs_rename_exit;
1743                 }
1744
1745                 info_buf_target = info_buf_source + 1;
1746                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1747                                              info_buf_source,
1748                                              cifs_sb->local_nls,
1749                                              cifs_remap(cifs_sb));
1750                 if (tmprc != 0)
1751                         goto unlink_target;
1752
1753                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1754                                              info_buf_target,
1755                                              cifs_sb->local_nls,
1756                                              cifs_remap(cifs_sb));
1757
1758                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1759                                    info_buf_target->UniqueId)) {
1760                         /* same file, POSIX says that this is a noop */
1761                         rc = 0;
1762                         goto cifs_rename_exit;
1763                 }
1764         }
1765         /*
1766          * else ... BB we could add the same check for Windows by
1767          * checking the UniqueId via FILE_INTERNAL_INFO
1768          */
1769
1770 unlink_target:
1771         /* Try unlinking the target dentry if it's not negative */
1772         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1773                 if (d_is_dir(target_dentry))
1774                         tmprc = cifs_rmdir(target_dir, target_dentry);
1775                 else
1776                         tmprc = cifs_unlink(target_dir, target_dentry);
1777                 if (tmprc)
1778                         goto cifs_rename_exit;
1779                 rc = cifs_do_rename(xid, source_dentry, from_name,
1780                                     target_dentry, to_name);
1781         }
1782
1783         /* force revalidate to go get info when needed */
1784         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1785
1786         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1787                 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1788
1789 cifs_rename_exit:
1790         kfree(info_buf_source);
1791         kfree(from_name);
1792         kfree(to_name);
1793         free_xid(xid);
1794         cifs_put_tlink(tlink);
1795         return rc;
1796 }
1797
1798 static bool
1799 cifs_inode_needs_reval(struct inode *inode)
1800 {
1801         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1802         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1803
1804         if (CIFS_CACHE_READ(cifs_i))
1805                 return false;
1806
1807         if (!lookupCacheEnabled)
1808                 return true;
1809
1810         if (cifs_i->time == 0)
1811                 return true;
1812
1813         if (!cifs_sb->actimeo)
1814                 return true;
1815
1816         if (!time_in_range(jiffies, cifs_i->time,
1817                                 cifs_i->time + cifs_sb->actimeo))
1818                 return true;
1819
1820         /* hardlinked files w/ noserverino get "special" treatment */
1821         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1822             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1823                 return true;
1824
1825         return false;
1826 }
1827
1828 /*
1829  * Zap the cache. Called when invalid_mapping flag is set.
1830  */
1831 int
1832 cifs_invalidate_mapping(struct inode *inode)
1833 {
1834         int rc = 0;
1835
1836         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1837                 rc = invalidate_inode_pages2(inode->i_mapping);
1838                 if (rc)
1839                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1840                                  __func__, inode);
1841         }
1842
1843         cifs_fscache_reset_inode_cookie(inode);
1844         return rc;
1845 }
1846
1847 /**
1848  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1849  * @word: long word containing the bit lock
1850  */
1851 static int
1852 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1853 {
1854         freezable_schedule_unsafe();
1855         if (signal_pending_state(mode, current))
1856                 return -ERESTARTSYS;
1857         return 0;
1858 }
1859
1860 int
1861 cifs_revalidate_mapping(struct inode *inode)
1862 {
1863         int rc;
1864         unsigned long *flags = &CIFS_I(inode)->flags;
1865
1866         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1867                                      TASK_KILLABLE);
1868         if (rc)
1869                 return rc;
1870
1871         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1872                 rc = cifs_invalidate_mapping(inode);
1873                 if (rc)
1874                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1875         }
1876
1877         clear_bit_unlock(CIFS_INO_LOCK, flags);
1878         smp_mb__after_atomic();
1879         wake_up_bit(flags, CIFS_INO_LOCK);
1880
1881         return rc;
1882 }
1883
1884 int
1885 cifs_zap_mapping(struct inode *inode)
1886 {
1887         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1888         return cifs_revalidate_mapping(inode);
1889 }
1890
1891 int cifs_revalidate_file_attr(struct file *filp)
1892 {
1893         int rc = 0;
1894         struct inode *inode = file_inode(filp);
1895         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1896
1897         if (!cifs_inode_needs_reval(inode))
1898                 return rc;
1899
1900         if (tlink_tcon(cfile->tlink)->unix_ext)
1901                 rc = cifs_get_file_info_unix(filp);
1902         else
1903                 rc = cifs_get_file_info(filp);
1904
1905         return rc;
1906 }
1907
1908 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1909 {
1910         unsigned int xid;
1911         int rc = 0;
1912         struct inode *inode = d_inode(dentry);
1913         struct super_block *sb = dentry->d_sb;
1914         char *full_path = NULL;
1915
1916         if (inode == NULL)
1917                 return -ENOENT;
1918
1919         if (!cifs_inode_needs_reval(inode))
1920                 return rc;
1921
1922         xid = get_xid();
1923
1924         /* can not safely grab the rename sem here if rename calls revalidate
1925            since that would deadlock */
1926         full_path = build_path_from_dentry(dentry);
1927         if (full_path == NULL) {
1928                 rc = -ENOMEM;
1929                 goto out;
1930         }
1931
1932         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1933                  full_path, inode, inode->i_count.counter,
1934                  dentry, dentry->d_time, jiffies);
1935
1936         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1937                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1938         else
1939                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1940                                          xid, NULL);
1941
1942 out:
1943         kfree(full_path);
1944         free_xid(xid);
1945         return rc;
1946 }
1947
1948 int cifs_revalidate_file(struct file *filp)
1949 {
1950         int rc;
1951         struct inode *inode = file_inode(filp);
1952
1953         rc = cifs_revalidate_file_attr(filp);
1954         if (rc)
1955                 return rc;
1956
1957         return cifs_revalidate_mapping(inode);
1958 }
1959
1960 /* revalidate a dentry's inode attributes */
1961 int cifs_revalidate_dentry(struct dentry *dentry)
1962 {
1963         int rc;
1964         struct inode *inode = d_inode(dentry);
1965
1966         rc = cifs_revalidate_dentry_attr(dentry);
1967         if (rc)
1968                 return rc;
1969
1970         return cifs_revalidate_mapping(inode);
1971 }
1972
1973 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1974                  struct kstat *stat)
1975 {
1976         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1977         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1978         struct inode *inode = d_inode(dentry);
1979         int rc;
1980
1981         /*
1982          * We need to be sure that all dirty pages are written and the server
1983          * has actual ctime, mtime and file length.
1984          */
1985         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1986             inode->i_mapping->nrpages != 0) {
1987                 rc = filemap_fdatawait(inode->i_mapping);
1988                 if (rc) {
1989                         mapping_set_error(inode->i_mapping, rc);
1990                         return rc;
1991                 }
1992         }
1993
1994         rc = cifs_revalidate_dentry_attr(dentry);
1995         if (rc)
1996                 return rc;
1997
1998         generic_fillattr(inode, stat);
1999         stat->blksize = CIFS_MAX_MSGSIZE;
2000         stat->ino = CIFS_I(inode)->uniqueid;
2001
2002         /*
2003          * If on a multiuser mount without unix extensions or cifsacl being
2004          * enabled, and the admin hasn't overridden them, set the ownership
2005          * to the fsuid/fsgid of the current process.
2006          */
2007         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2008             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2009             !tcon->unix_ext) {
2010                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2011                         stat->uid = current_fsuid();
2012                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2013                         stat->gid = current_fsgid();
2014         }
2015         return rc;
2016 }
2017
2018 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2019 {
2020         pgoff_t index = from >> PAGE_CACHE_SHIFT;
2021         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
2022         struct page *page;
2023         int rc = 0;
2024
2025         page = grab_cache_page(mapping, index);
2026         if (!page)
2027                 return -ENOMEM;
2028
2029         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
2030         unlock_page(page);
2031         page_cache_release(page);
2032         return rc;
2033 }
2034
2035 static void cifs_setsize(struct inode *inode, loff_t offset)
2036 {
2037         spin_lock(&inode->i_lock);
2038         i_size_write(inode, offset);
2039         spin_unlock(&inode->i_lock);
2040
2041         truncate_pagecache(inode, offset);
2042 }
2043
2044 static int
2045 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2046                    unsigned int xid, char *full_path)
2047 {
2048         int rc;
2049         struct cifsFileInfo *open_file;
2050         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2051         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2052         struct tcon_link *tlink = NULL;
2053         struct cifs_tcon *tcon = NULL;
2054         struct TCP_Server_Info *server;
2055
2056         /*
2057          * To avoid spurious oplock breaks from server, in the case of
2058          * inodes that we already have open, avoid doing path based
2059          * setting of file size if we can do it by handle.
2060          * This keeps our caching token (oplock) and avoids timeouts
2061          * when the local oplock break takes longer to flush
2062          * writebehind data than the SMB timeout for the SetPathInfo
2063          * request would allow
2064          */
2065         open_file = find_writable_file(cifsInode, true);
2066         if (open_file) {
2067                 tcon = tlink_tcon(open_file->tlink);
2068                 server = tcon->ses->server;
2069                 if (server->ops->set_file_size)
2070                         rc = server->ops->set_file_size(xid, tcon, open_file,
2071                                                         attrs->ia_size, false);
2072                 else
2073                         rc = -ENOSYS;
2074                 cifsFileInfo_put(open_file);
2075                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2076         } else
2077                 rc = -EINVAL;
2078
2079         if (!rc)
2080                 goto set_size_out;
2081
2082         if (tcon == NULL) {
2083                 tlink = cifs_sb_tlink(cifs_sb);
2084                 if (IS_ERR(tlink))
2085                         return PTR_ERR(tlink);
2086                 tcon = tlink_tcon(tlink);
2087                 server = tcon->ses->server;
2088         }
2089
2090         /*
2091          * Set file size by pathname rather than by handle either because no
2092          * valid, writeable file handle for it was found or because there was
2093          * an error setting it by handle.
2094          */
2095         if (server->ops->set_path_size)
2096                 rc = server->ops->set_path_size(xid, tcon, full_path,
2097                                                 attrs->ia_size, cifs_sb, false);
2098         else
2099                 rc = -ENOSYS;
2100         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2101
2102         if (tlink)
2103                 cifs_put_tlink(tlink);
2104
2105 set_size_out:
2106         if (rc == 0) {
2107                 cifsInode->server_eof = attrs->ia_size;
2108                 cifs_setsize(inode, attrs->ia_size);
2109                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2110         }
2111
2112         return rc;
2113 }
2114
2115 static int
2116 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2117 {
2118         int rc;
2119         unsigned int xid;
2120         char *full_path = NULL;
2121         struct inode *inode = d_inode(direntry);
2122         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2123         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2124         struct tcon_link *tlink;
2125         struct cifs_tcon *pTcon;
2126         struct cifs_unix_set_info_args *args = NULL;
2127         struct cifsFileInfo *open_file;
2128
2129         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2130                  direntry, attrs->ia_valid);
2131
2132         xid = get_xid();
2133
2134         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2135                 attrs->ia_valid |= ATTR_FORCE;
2136
2137         rc = inode_change_ok(inode, attrs);
2138         if (rc < 0)
2139                 goto out;
2140
2141         full_path = build_path_from_dentry(direntry);
2142         if (full_path == NULL) {
2143                 rc = -ENOMEM;
2144                 goto out;
2145         }
2146
2147         /*
2148          * Attempt to flush data before changing attributes. We need to do
2149          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2150          * ownership or mode then we may also need to do this. Here, we take
2151          * the safe way out and just do the flush on all setattr requests. If
2152          * the flush returns error, store it to report later and continue.
2153          *
2154          * BB: This should be smarter. Why bother flushing pages that
2155          * will be truncated anyway? Also, should we error out here if
2156          * the flush returns error?
2157          */
2158         rc = filemap_write_and_wait(inode->i_mapping);
2159         mapping_set_error(inode->i_mapping, rc);
2160         rc = 0;
2161
2162         if (attrs->ia_valid & ATTR_SIZE) {
2163                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2164                 if (rc != 0)
2165                         goto out;
2166         }
2167
2168         /* skip mode change if it's just for clearing setuid/setgid */
2169         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2170                 attrs->ia_valid &= ~ATTR_MODE;
2171
2172         args = kmalloc(sizeof(*args), GFP_KERNEL);
2173         if (args == NULL) {
2174                 rc = -ENOMEM;
2175                 goto out;
2176         }
2177
2178         /* set up the struct */
2179         if (attrs->ia_valid & ATTR_MODE)
2180                 args->mode = attrs->ia_mode;
2181         else
2182                 args->mode = NO_CHANGE_64;
2183
2184         if (attrs->ia_valid & ATTR_UID)
2185                 args->uid = attrs->ia_uid;
2186         else
2187                 args->uid = INVALID_UID; /* no change */
2188
2189         if (attrs->ia_valid & ATTR_GID)
2190                 args->gid = attrs->ia_gid;
2191         else
2192                 args->gid = INVALID_GID; /* no change */
2193
2194         if (attrs->ia_valid & ATTR_ATIME)
2195                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2196         else
2197                 args->atime = NO_CHANGE_64;
2198
2199         if (attrs->ia_valid & ATTR_MTIME)
2200                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2201         else
2202                 args->mtime = NO_CHANGE_64;
2203
2204         if (attrs->ia_valid & ATTR_CTIME)
2205                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2206         else
2207                 args->ctime = NO_CHANGE_64;
2208
2209         args->device = 0;
2210         open_file = find_writable_file(cifsInode, true);
2211         if (open_file) {
2212                 u16 nfid = open_file->fid.netfid;
2213                 u32 npid = open_file->pid;
2214                 pTcon = tlink_tcon(open_file->tlink);
2215                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2216                 cifsFileInfo_put(open_file);
2217         } else {
2218                 tlink = cifs_sb_tlink(cifs_sb);
2219                 if (IS_ERR(tlink)) {
2220                         rc = PTR_ERR(tlink);
2221                         goto out;
2222                 }
2223                 pTcon = tlink_tcon(tlink);
2224                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2225                                     cifs_sb->local_nls,
2226                                     cifs_remap(cifs_sb));
2227                 cifs_put_tlink(tlink);
2228         }
2229
2230         if (rc)
2231                 goto out;
2232
2233         if ((attrs->ia_valid & ATTR_SIZE) &&
2234             attrs->ia_size != i_size_read(inode))
2235                 truncate_setsize(inode, attrs->ia_size);
2236
2237         setattr_copy(inode, attrs);
2238         mark_inode_dirty(inode);
2239
2240         /* force revalidate when any of these times are set since some
2241            of the fs types (eg ext3, fat) do not have fine enough
2242            time granularity to match protocol, and we do not have a
2243            a way (yet) to query the server fs's time granularity (and
2244            whether it rounds times down).
2245         */
2246         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2247                 cifsInode->time = 0;
2248 out:
2249         kfree(args);
2250         kfree(full_path);
2251         free_xid(xid);
2252         return rc;
2253 }
2254
2255 static int
2256 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2257 {
2258         unsigned int xid;
2259         kuid_t uid = INVALID_UID;
2260         kgid_t gid = INVALID_GID;
2261         struct inode *inode = d_inode(direntry);
2262         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2263         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2264         char *full_path = NULL;
2265         int rc = -EACCES;
2266         __u32 dosattr = 0;
2267         __u64 mode = NO_CHANGE_64;
2268
2269         xid = get_xid();
2270
2271         cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2272                  direntry, attrs->ia_valid);
2273
2274         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2275                 attrs->ia_valid |= ATTR_FORCE;
2276
2277         rc = inode_change_ok(inode, attrs);
2278         if (rc < 0) {
2279                 free_xid(xid);
2280                 return rc;
2281         }
2282
2283         full_path = build_path_from_dentry(direntry);
2284         if (full_path == NULL) {
2285                 rc = -ENOMEM;
2286                 free_xid(xid);
2287                 return rc;
2288         }
2289
2290         /*
2291          * Attempt to flush data before changing attributes. We need to do
2292          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2293          * ownership or mode then we may also need to do this. Here, we take
2294          * the safe way out and just do the flush on all setattr requests. If
2295          * the flush returns error, store it to report later and continue.
2296          *
2297          * BB: This should be smarter. Why bother flushing pages that
2298          * will be truncated anyway? Also, should we error out here if
2299          * the flush returns error?
2300          */
2301         rc = filemap_write_and_wait(inode->i_mapping);
2302         mapping_set_error(inode->i_mapping, rc);
2303         rc = 0;
2304
2305         if (attrs->ia_valid & ATTR_SIZE) {
2306                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2307                 if (rc != 0)
2308                         goto cifs_setattr_exit;
2309         }
2310
2311         if (attrs->ia_valid & ATTR_UID)
2312                 uid = attrs->ia_uid;
2313
2314         if (attrs->ia_valid & ATTR_GID)
2315                 gid = attrs->ia_gid;
2316
2317 #ifdef CONFIG_CIFS_ACL
2318         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2319                 if (uid_valid(uid) || gid_valid(gid)) {
2320                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2321                                                         uid, gid);
2322                         if (rc) {
2323                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2324                                          __func__, rc);
2325                                 goto cifs_setattr_exit;
2326                         }
2327                 }
2328         } else
2329 #endif /* CONFIG_CIFS_ACL */
2330         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2331                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2332
2333         /* skip mode change if it's just for clearing setuid/setgid */
2334         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2335                 attrs->ia_valid &= ~ATTR_MODE;
2336
2337         if (attrs->ia_valid & ATTR_MODE) {
2338                 mode = attrs->ia_mode;
2339                 rc = 0;
2340 #ifdef CONFIG_CIFS_ACL
2341                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2342                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2343                                                 INVALID_UID, INVALID_GID);
2344                         if (rc) {
2345                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2346                                          __func__, rc);
2347                                 goto cifs_setattr_exit;
2348                         }
2349                 } else
2350 #endif /* CONFIG_CIFS_ACL */
2351                 if (((mode & S_IWUGO) == 0) &&
2352                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2353
2354                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2355
2356                         /* fix up mode if we're not using dynperm */
2357                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2358                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2359                 } else if ((mode & S_IWUGO) &&
2360                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2361
2362                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2363                         /* Attributes of 0 are ignored */
2364                         if (dosattr == 0)
2365                                 dosattr |= ATTR_NORMAL;
2366
2367                         /* reset local inode permissions to normal */
2368                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2369                                 attrs->ia_mode &= ~(S_IALLUGO);
2370                                 if (S_ISDIR(inode->i_mode))
2371                                         attrs->ia_mode |=
2372                                                 cifs_sb->mnt_dir_mode;
2373                                 else
2374                                         attrs->ia_mode |=
2375                                                 cifs_sb->mnt_file_mode;
2376                         }
2377                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2378                         /* ignore mode change - ATTR_READONLY hasn't changed */
2379                         attrs->ia_valid &= ~ATTR_MODE;
2380                 }
2381         }
2382
2383         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2384             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2385                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2386                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2387
2388                 /* Even if error on time set, no sense failing the call if
2389                 the server would set the time to a reasonable value anyway,
2390                 and this check ensures that we are not being called from
2391                 sys_utimes in which case we ought to fail the call back to
2392                 the user when the server rejects the call */
2393                 if ((rc) && (attrs->ia_valid &
2394                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2395                         rc = 0;
2396         }
2397
2398         /* do not need local check to inode_check_ok since the server does
2399            that */
2400         if (rc)
2401                 goto cifs_setattr_exit;
2402
2403         if ((attrs->ia_valid & ATTR_SIZE) &&
2404             attrs->ia_size != i_size_read(inode))
2405                 truncate_setsize(inode, attrs->ia_size);
2406
2407         setattr_copy(inode, attrs);
2408         mark_inode_dirty(inode);
2409
2410 cifs_setattr_exit:
2411         kfree(full_path);
2412         free_xid(xid);
2413         return rc;
2414 }
2415
2416 int
2417 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2418 {
2419         struct inode *inode = d_inode(direntry);
2420         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2421         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2422
2423         if (pTcon->unix_ext)
2424                 return cifs_setattr_unix(direntry, attrs);
2425
2426         return cifs_setattr_nounix(direntry, attrs);
2427
2428         /* BB: add cifs_setattr_legacy for really old servers */
2429 }
2430
2431 #if 0
2432 void cifs_delete_inode(struct inode *inode)
2433 {
2434         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2435         /* may have to add back in if and when safe distributed caching of
2436            directories added e.g. via FindNotify */
2437 }
2438 #endif