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