fs/cifs/inode.c

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