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