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