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                         if (pTcon->nocase)
1328                                 d_set_d_op(direntry, &cifs_ci_dentry_ops);
1329                         else
1330                                 d_set_d_op(direntry, &cifs_dentry_ops);
1331
1332                         cifs_unix_basic_to_fattr(&fattr, pInfo, cifs_sb);
1333                         cifs_fill_uniqueid(inode->i_sb, &fattr);
1334                         newinode = cifs_iget(inode->i_sb, &fattr);
1335                         if (!newinode) {
1336                                 kfree(pInfo);
1337                                 goto mkdir_get_info;
1338                         }
1339
1340                         d_instantiate(direntry, newinode);
1341
1342 #ifdef CONFIG_CIFS_DEBUG2
1343                         cFYI(1, "instantiated dentry %p %s to inode %p",
1344                                 direntry, direntry->d_name.name, newinode);
1345
1346                         if (newinode->i_nlink != 2)
1347                                 cFYI(1, "unexpected number of links %d",
1348                                         newinode->i_nlink);
1349 #endif
1350                 }
1351                 kfree(pInfo);
1352                 goto mkdir_out;
1353         }
1354 mkdir_retry_old:
1355         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1356         rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1357                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1358         if (rc) {
1359                 cFYI(1, "cifs_mkdir returned 0x%x", rc);
1360                 d_drop(direntry);
1361         } else {
1362 mkdir_get_info:
1363                 inc_nlink(inode);
1364                 if (pTcon->unix_ext)
1365                         rc = cifs_get_inode_info_unix(&newinode, full_path,
1366                                                       inode->i_sb, xid);
1367                 else
1368                         rc = cifs_get_inode_info(&newinode, full_path, NULL,
1369                                                  inode->i_sb, xid, NULL);
1370
1371                 if (pTcon->nocase)
1372                         d_set_d_op(direntry, &cifs_ci_dentry_ops);
1373                 else
1374                         d_set_d_op(direntry, &cifs_dentry_ops);
1375                 d_instantiate(direntry, newinode);
1376                  /* setting nlink not necessary except in cases where we
1377                   * failed to get it from the server or was set bogus */
1378                 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1379                                 direntry->d_inode->i_nlink = 2;
1380
1381                 mode &= ~current_umask();
1382                 /* must turn on setgid bit if parent dir has it */
1383                 if (inode->i_mode & S_ISGID)
1384                         mode |= S_ISGID;
1385
1386                 if (pTcon->unix_ext) {
1387                         struct cifs_unix_set_info_args args = {
1388                                 .mode   = mode,
1389                                 .ctime  = NO_CHANGE_64,
1390                                 .atime  = NO_CHANGE_64,
1391                                 .mtime  = NO_CHANGE_64,
1392                                 .device = 0,
1393                         };
1394                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1395                                 args.uid = (__u64)current_fsuid();
1396                                 if (inode->i_mode & S_ISGID)
1397                                         args.gid = (__u64)inode->i_gid;
1398                                 else
1399                                         args.gid = (__u64)current_fsgid();
1400                         } else {
1401                                 args.uid = NO_CHANGE_64;
1402                                 args.gid = NO_CHANGE_64;
1403                         }
1404                         CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
1405                                                cifs_sb->local_nls,
1406                                                cifs_sb->mnt_cifs_flags &
1407                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1408                 } else {
1409                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1410                             (mode & S_IWUGO) == 0) {
1411                                 FILE_BASIC_INFO pInfo;
1412                                 struct cifsInodeInfo *cifsInode;
1413                                 u32 dosattrs;
1414
1415                                 memset(&pInfo, 0, sizeof(pInfo));
1416                                 cifsInode = CIFS_I(newinode);
1417                                 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1418                                 pInfo.Attributes = cpu_to_le32(dosattrs);
1419                                 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1420                                                 full_path, &pInfo,
1421                                                 cifs_sb->local_nls,
1422                                                 cifs_sb->mnt_cifs_flags &
1423                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1424                                 if (tmprc == 0)
1425                                         cifsInode->cifsAttrs = dosattrs;
1426                         }
1427                         if (direntry->d_inode) {
1428                                 if (cifs_sb->mnt_cifs_flags &
1429                                      CIFS_MOUNT_DYNPERM)
1430                                         direntry->d_inode->i_mode =
1431                                                 (mode | S_IFDIR);
1432
1433                                 if (cifs_sb->mnt_cifs_flags &
1434                                      CIFS_MOUNT_SET_UID) {
1435                                         direntry->d_inode->i_uid =
1436                                                 current_fsuid();
1437                                         if (inode->i_mode & S_ISGID)
1438                                                 direntry->d_inode->i_gid =
1439                                                         inode->i_gid;
1440                                         else
1441                                                 direntry->d_inode->i_gid =
1442                                                         current_fsgid();
1443                                 }
1444                         }
1445                 }
1446         }
1447 mkdir_out:
1448         kfree(full_path);
1449         FreeXid(xid);
1450         cifs_put_tlink(tlink);
1451         return rc;
1452 }
1453
1454 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1455 {
1456         int rc = 0;
1457         int xid;
1458         struct cifs_sb_info *cifs_sb;
1459         struct tcon_link *tlink;
1460         struct cifsTconInfo *pTcon;
1461         char *full_path = NULL;
1462         struct cifsInodeInfo *cifsInode;
1463
1464         cFYI(1, "cifs_rmdir, inode = 0x%p", inode);
1465
1466         xid = GetXid();
1467
1468         full_path = build_path_from_dentry(direntry);
1469         if (full_path == NULL) {
1470                 rc = -ENOMEM;
1471                 goto rmdir_exit;
1472         }
1473
1474         cifs_sb = CIFS_SB(inode->i_sb);
1475         tlink = cifs_sb_tlink(cifs_sb);
1476         if (IS_ERR(tlink)) {
1477                 rc = PTR_ERR(tlink);
1478                 goto rmdir_exit;
1479         }
1480         pTcon = tlink_tcon(tlink);
1481
1482         rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1483                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1484         cifs_put_tlink(tlink);
1485
1486         if (!rc) {
1487                 drop_nlink(inode);
1488                 spin_lock(&direntry->d_inode->i_lock);
1489                 i_size_write(direntry->d_inode, 0);
1490                 clear_nlink(direntry->d_inode);
1491                 spin_unlock(&direntry->d_inode->i_lock);
1492         }
1493
1494         cifsInode = CIFS_I(direntry->d_inode);
1495         cifsInode->time = 0;    /* force revalidate to go get info when
1496                                    needed */
1497
1498         cifsInode = CIFS_I(inode);
1499         cifsInode->time = 0;    /* force revalidate to get parent dir info
1500                                    since cached search results now invalid */
1501
1502         direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1503                 current_fs_time(inode->i_sb);
1504
1505 rmdir_exit:
1506         kfree(full_path);
1507         FreeXid(xid);
1508         return rc;
1509 }
1510
1511 static int
1512 cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1513                 struct dentry *to_dentry, const char *toPath)
1514 {
1515         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1516         struct tcon_link *tlink;
1517         struct cifsTconInfo *pTcon;
1518         __u16 srcfid;
1519         int oplock, rc;
1520
1521         tlink = cifs_sb_tlink(cifs_sb);
1522         if (IS_ERR(tlink))
1523                 return PTR_ERR(tlink);
1524         pTcon = tlink_tcon(tlink);
1525
1526         /* try path-based rename first */
1527         rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1528                            cifs_sb->mnt_cifs_flags &
1529                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1530
1531         /*
1532          * don't bother with rename by filehandle unless file is busy and
1533          * source Note that cross directory moves do not work with
1534          * rename by filehandle to various Windows servers.
1535          */
1536         if (rc == 0 || rc != -ETXTBSY)
1537                 goto do_rename_exit;
1538
1539         /* open-file renames don't work across directories */
1540         if (to_dentry->d_parent != from_dentry->d_parent)
1541                 goto do_rename_exit;
1542
1543         /* open the file to be renamed -- we need DELETE perms */
1544         rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1545                          CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1546                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1547                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1548
1549         if (rc == 0) {
1550                 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1551                                 (const char *) to_dentry->d_name.name,
1552                                 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1553                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1554
1555                 CIFSSMBClose(xid, pTcon, srcfid);
1556         }
1557 do_rename_exit:
1558         cifs_put_tlink(tlink);
1559         return rc;
1560 }
1561
1562 int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1563         struct inode *target_dir, struct dentry *target_dentry)
1564 {
1565         char *fromName = NULL;
1566         char *toName = NULL;
1567         struct cifs_sb_info *cifs_sb;
1568         struct tcon_link *tlink;
1569         struct cifsTconInfo *tcon;
1570         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1571         FILE_UNIX_BASIC_INFO *info_buf_target;
1572         int xid, rc, tmprc;
1573
1574         cifs_sb = CIFS_SB(source_dir->i_sb);
1575         tlink = cifs_sb_tlink(cifs_sb);
1576         if (IS_ERR(tlink))
1577                 return PTR_ERR(tlink);
1578         tcon = tlink_tcon(tlink);
1579
1580         xid = GetXid();
1581
1582         /*
1583          * we already have the rename sem so we do not need to
1584          * grab it again here to protect the path integrity
1585          */
1586         fromName = build_path_from_dentry(source_dentry);
1587         if (fromName == NULL) {
1588                 rc = -ENOMEM;
1589                 goto cifs_rename_exit;
1590         }
1591
1592         toName = build_path_from_dentry(target_dentry);
1593         if (toName == NULL) {
1594                 rc = -ENOMEM;
1595                 goto cifs_rename_exit;
1596         }
1597
1598         rc = cifs_do_rename(xid, source_dentry, fromName,
1599                             target_dentry, toName);
1600
1601         if (rc == -EEXIST && tcon->unix_ext) {
1602                 /*
1603                  * Are src and dst hardlinks of same inode? We can
1604                  * only tell with unix extensions enabled
1605                  */
1606                 info_buf_source =
1607                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1608                                         GFP_KERNEL);
1609                 if (info_buf_source == NULL) {
1610                         rc = -ENOMEM;
1611                         goto cifs_rename_exit;
1612                 }
1613
1614                 info_buf_target = info_buf_source + 1;
1615                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
1616                                         info_buf_source,
1617                                         cifs_sb->local_nls,
1618                                         cifs_sb->mnt_cifs_flags &
1619                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1620                 if (tmprc != 0)
1621                         goto unlink_target;
1622
1623                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, toName,
1624                                         info_buf_target,
1625                                         cifs_sb->local_nls,
1626                                         cifs_sb->mnt_cifs_flags &
1627                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1628
1629                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1630                                    info_buf_target->UniqueId)) {
1631                         /* same file, POSIX says that this is a noop */
1632                         rc = 0;
1633                         goto cifs_rename_exit;
1634                 }
1635         } /* else ... BB we could add the same check for Windows by
1636                      checking the UniqueId via FILE_INTERNAL_INFO */
1637
1638 unlink_target:
1639         /* Try unlinking the target dentry if it's not negative */
1640         if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1641                 tmprc = cifs_unlink(target_dir, target_dentry);
1642                 if (tmprc)
1643                         goto cifs_rename_exit;
1644
1645                 rc = cifs_do_rename(xid, source_dentry, fromName,
1646                                     target_dentry, toName);
1647         }
1648
1649 cifs_rename_exit:
1650         kfree(info_buf_source);
1651         kfree(fromName);
1652         kfree(toName);
1653         FreeXid(xid);
1654         cifs_put_tlink(tlink);
1655         return rc;
1656 }
1657
1658 static bool
1659 cifs_inode_needs_reval(struct inode *inode)
1660 {
1661         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1662         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1663
1664         if (cifs_i->clientCanCacheRead)
1665                 return false;
1666
1667         if (!lookupCacheEnabled)
1668                 return true;
1669
1670         if (cifs_i->time == 0)
1671                 return true;
1672
1673         if (!time_in_range(jiffies, cifs_i->time,
1674                                 cifs_i->time + cifs_sb->actimeo))
1675                 return true;
1676
1677         /* hardlinked files w/ noserverino get "special" treatment */
1678         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1679             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1680                 return true;
1681
1682         return false;
1683 }
1684
1685 /*
1686  * Zap the cache. Called when invalid_mapping flag is set.
1687  */
1688 static void
1689 cifs_invalidate_mapping(struct inode *inode)
1690 {
1691         int rc;
1692         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1693
1694         cifs_i->invalid_mapping = false;
1695
1696         /* write back any cached data */
1697         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1698                 rc = filemap_write_and_wait(inode->i_mapping);
1699                 mapping_set_error(inode->i_mapping, rc);
1700         }
1701         invalidate_remote_inode(inode);
1702         cifs_fscache_reset_inode_cookie(inode);
1703 }
1704
1705 int cifs_revalidate_file(struct file *filp)
1706 {
1707         int rc = 0;
1708         struct inode *inode = filp->f_path.dentry->d_inode;
1709         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1710
1711         if (!cifs_inode_needs_reval(inode))
1712                 goto check_inval;
1713
1714         if (tlink_tcon(cfile->tlink)->unix_ext)
1715                 rc = cifs_get_file_info_unix(filp);
1716         else
1717                 rc = cifs_get_file_info(filp);
1718
1719 check_inval:
1720         if (CIFS_I(inode)->invalid_mapping)
1721                 cifs_invalidate_mapping(inode);
1722
1723         return rc;
1724 }
1725
1726 /* revalidate a dentry's inode attributes */
1727 int cifs_revalidate_dentry(struct dentry *dentry)
1728 {
1729         int xid;
1730         int rc = 0;
1731         char *full_path = NULL;
1732         struct inode *inode = dentry->d_inode;
1733         struct super_block *sb = dentry->d_sb;
1734
1735         if (inode == NULL)
1736                 return -ENOENT;
1737
1738         xid = GetXid();
1739
1740         if (!cifs_inode_needs_reval(inode))
1741                 goto check_inval;
1742
1743         /* can not safely grab the rename sem here if rename calls revalidate
1744            since that would deadlock */
1745         full_path = build_path_from_dentry(dentry);
1746         if (full_path == NULL) {
1747                 rc = -ENOMEM;
1748                 goto check_inval;
1749         }
1750
1751         cFYI(1, "Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1752                  "jiffies %ld", full_path, inode, inode->i_count.counter,
1753                  dentry, dentry->d_time, jiffies);
1754
1755         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1756                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1757         else
1758                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1759                                          xid, NULL);
1760
1761 check_inval:
1762         if (CIFS_I(inode)->invalid_mapping)
1763                 cifs_invalidate_mapping(inode);
1764
1765         kfree(full_path);
1766         FreeXid(xid);
1767         return rc;
1768 }
1769
1770 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1771                  struct kstat *stat)
1772 {
1773         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1774         struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
1775         int err = cifs_revalidate_dentry(dentry);
1776
1777         if (!err) {
1778                 generic_fillattr(dentry->d_inode, stat);
1779                 stat->blksize = CIFS_MAX_MSGSIZE;
1780                 stat->ino = CIFS_I(dentry->d_inode)->uniqueid;
1781
1782                 /*
1783                  * If on a multiuser mount without unix extensions, and the
1784                  * admin hasn't overridden them, set the ownership to the
1785                  * fsuid/fsgid of the current process.
1786                  */
1787                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1788                     !tcon->unix_ext) {
1789                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1790                                 stat->uid = current_fsuid();
1791                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1792                                 stat->gid = current_fsgid();
1793                 }
1794         }
1795         return err;
1796 }
1797
1798 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1799 {
1800         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1801         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1802         struct page *page;
1803         int rc = 0;
1804
1805         page = grab_cache_page(mapping, index);
1806         if (!page)
1807                 return -ENOMEM;
1808
1809         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1810         unlock_page(page);
1811         page_cache_release(page);
1812         return rc;
1813 }
1814
1815 static void cifs_setsize(struct inode *inode, loff_t offset)
1816 {
1817         loff_t oldsize;
1818
1819         spin_lock(&inode->i_lock);
1820         oldsize = inode->i_size;
1821         i_size_write(inode, offset);
1822         spin_unlock(&inode->i_lock);
1823
1824         truncate_pagecache(inode, oldsize, offset);
1825 }
1826
1827 static int
1828 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1829                    int xid, char *full_path)
1830 {
1831         int rc;
1832         struct cifsFileInfo *open_file;
1833         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1834         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1835         struct tcon_link *tlink = NULL;
1836         struct cifsTconInfo *pTcon = NULL;
1837
1838         /*
1839          * To avoid spurious oplock breaks from server, in the case of
1840          * inodes that we already have open, avoid doing path based
1841          * setting of file size if we can do it by handle.
1842          * This keeps our caching token (oplock) and avoids timeouts
1843          * when the local oplock break takes longer to flush
1844          * writebehind data than the SMB timeout for the SetPathInfo
1845          * request would allow
1846          */
1847         open_file = find_writable_file(cifsInode, true);
1848         if (open_file) {
1849                 __u16 nfid = open_file->netfid;
1850                 __u32 npid = open_file->pid;
1851                 pTcon = tlink_tcon(open_file->tlink);
1852                 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1853                                         npid, false);
1854                 cifsFileInfo_put(open_file);
1855                 cFYI(1, "SetFSize for attrs rc = %d", rc);
1856                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1857                         unsigned int bytes_written;
1858                         rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1859                                           &bytes_written, NULL, NULL, 1);
1860                         cFYI(1, "Wrt seteof rc %d", rc);
1861                 }
1862         } else
1863                 rc = -EINVAL;
1864
1865         if (rc != 0) {
1866                 if (pTcon == NULL) {
1867                         tlink = cifs_sb_tlink(cifs_sb);
1868                         if (IS_ERR(tlink))
1869                                 return PTR_ERR(tlink);
1870                         pTcon = tlink_tcon(tlink);
1871                 }
1872
1873                 /* Set file size by pathname rather than by handle
1874                    either because no valid, writeable file handle for
1875                    it was found or because there was an error setting
1876                    it by handle */
1877                 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1878                                    false, cifs_sb->local_nls,
1879                                    cifs_sb->mnt_cifs_flags &
1880                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1881                 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1882                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1883                         __u16 netfid;
1884                         int oplock = 0;
1885
1886                         rc = SMBLegacyOpen(xid, pTcon, full_path,
1887                                 FILE_OPEN, GENERIC_WRITE,
1888                                 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1889                                 cifs_sb->local_nls,
1890                                 cifs_sb->mnt_cifs_flags &
1891                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1892                         if (rc == 0) {
1893                                 unsigned int bytes_written;
1894                                 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1895                                                   attrs->ia_size,
1896                                                   &bytes_written, NULL,
1897                                                   NULL, 1);
1898                                 cFYI(1, "wrt seteof rc %d", rc);
1899                                 CIFSSMBClose(xid, pTcon, netfid);
1900                         }
1901                 }
1902                 if (tlink)
1903                         cifs_put_tlink(tlink);
1904         }
1905
1906         if (rc == 0) {
1907                 cifsInode->server_eof = attrs->ia_size;
1908                 cifs_setsize(inode, attrs->ia_size);
1909                 cifs_truncate_page(inode->i_mapping, inode->i_size);
1910         }
1911
1912         return rc;
1913 }
1914
1915 static int
1916 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1917 {
1918         int rc;
1919         int xid;
1920         char *full_path = NULL;
1921         struct inode *inode = direntry->d_inode;
1922         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1923         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1924         struct tcon_link *tlink;
1925         struct cifsTconInfo *pTcon;
1926         struct cifs_unix_set_info_args *args = NULL;
1927         struct cifsFileInfo *open_file;
1928
1929         cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1930                  direntry->d_name.name, attrs->ia_valid);
1931
1932         xid = GetXid();
1933
1934         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1935                 attrs->ia_valid |= ATTR_FORCE;
1936
1937         rc = inode_change_ok(inode, attrs);
1938         if (rc < 0)
1939                 goto out;
1940
1941         full_path = build_path_from_dentry(direntry);
1942         if (full_path == NULL) {
1943                 rc = -ENOMEM;
1944                 goto out;
1945         }
1946
1947         /*
1948          * Attempt to flush data before changing attributes. We need to do
1949          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1950          * ownership or mode then we may also need to do this. Here, we take
1951          * the safe way out and just do the flush on all setattr requests. If
1952          * the flush returns error, store it to report later and continue.
1953          *
1954          * BB: This should be smarter. Why bother flushing pages that
1955          * will be truncated anyway? Also, should we error out here if
1956          * the flush returns error?
1957          */
1958         rc = filemap_write_and_wait(inode->i_mapping);
1959         mapping_set_error(inode->i_mapping, rc);
1960         rc = 0;
1961
1962         if (attrs->ia_valid & ATTR_SIZE) {
1963                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1964                 if (rc != 0)
1965                         goto out;
1966         }
1967
1968         /* skip mode change if it's just for clearing setuid/setgid */
1969         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1970                 attrs->ia_valid &= ~ATTR_MODE;
1971
1972         args = kmalloc(sizeof(*args), GFP_KERNEL);
1973         if (args == NULL) {
1974                 rc = -ENOMEM;
1975                 goto out;
1976         }
1977
1978         /* set up the struct */
1979         if (attrs->ia_valid & ATTR_MODE)
1980                 args->mode = attrs->ia_mode;
1981         else
1982                 args->mode = NO_CHANGE_64;
1983
1984         if (attrs->ia_valid & ATTR_UID)
1985                 args->uid = attrs->ia_uid;
1986         else
1987                 args->uid = NO_CHANGE_64;
1988
1989         if (attrs->ia_valid & ATTR_GID)
1990                 args->gid = attrs->ia_gid;
1991         else
1992                 args->gid = NO_CHANGE_64;
1993
1994         if (attrs->ia_valid & ATTR_ATIME)
1995                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1996         else
1997                 args->atime = NO_CHANGE_64;
1998
1999         if (attrs->ia_valid & ATTR_MTIME)
2000                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2001         else
2002                 args->mtime = NO_CHANGE_64;
2003
2004         if (attrs->ia_valid & ATTR_CTIME)
2005                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2006         else
2007                 args->ctime = NO_CHANGE_64;
2008
2009         args->device = 0;
2010         open_file = find_writable_file(cifsInode, true);
2011         if (open_file) {
2012                 u16 nfid = open_file->netfid;
2013                 u32 npid = open_file->pid;
2014                 pTcon = tlink_tcon(open_file->tlink);
2015                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2016                 cifsFileInfo_put(open_file);
2017         } else {
2018                 tlink = cifs_sb_tlink(cifs_sb);
2019                 if (IS_ERR(tlink)) {
2020                         rc = PTR_ERR(tlink);
2021                         goto out;
2022                 }
2023                 pTcon = tlink_tcon(tlink);
2024                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2025                                     cifs_sb->local_nls,
2026                                     cifs_sb->mnt_cifs_flags &
2027                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
2028                 cifs_put_tlink(tlink);
2029         }
2030
2031         if (rc)
2032                 goto out;
2033
2034         if ((attrs->ia_valid & ATTR_SIZE) &&
2035             attrs->ia_size != i_size_read(inode))
2036                 truncate_setsize(inode, attrs->ia_size);
2037
2038         setattr_copy(inode, attrs);
2039         mark_inode_dirty(inode);
2040
2041         /* force revalidate when any of these times are set since some
2042            of the fs types (eg ext3, fat) do not have fine enough
2043            time granularity to match protocol, and we do not have a
2044            a way (yet) to query the server fs's time granularity (and
2045            whether it rounds times down).
2046         */
2047         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2048                 cifsInode->time = 0;
2049 out:
2050         kfree(args);
2051         kfree(full_path);
2052         FreeXid(xid);
2053         return rc;
2054 }
2055
2056 static int
2057 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2058 {
2059         int xid;
2060         struct inode *inode = direntry->d_inode;
2061         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2062         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2063         char *full_path = NULL;
2064         int rc = -EACCES;
2065         __u32 dosattr = 0;
2066         __u64 mode = NO_CHANGE_64;
2067
2068         xid = GetXid();
2069
2070         cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2071                  direntry->d_name.name, attrs->ia_valid);
2072
2073         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2074                 attrs->ia_valid |= ATTR_FORCE;
2075
2076         rc = inode_change_ok(inode, attrs);
2077         if (rc < 0) {
2078                 FreeXid(xid);
2079                 return rc;
2080         }
2081
2082         full_path = build_path_from_dentry(direntry);
2083         if (full_path == NULL) {
2084                 rc = -ENOMEM;
2085                 FreeXid(xid);
2086                 return rc;
2087         }
2088
2089         /*
2090          * Attempt to flush data before changing attributes. We need to do
2091          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2092          * ownership or mode then we may also need to do this. Here, we take
2093          * the safe way out and just do the flush on all setattr requests. If
2094          * the flush returns error, store it to report later and continue.
2095          *
2096          * BB: This should be smarter. Why bother flushing pages that
2097          * will be truncated anyway? Also, should we error out here if
2098          * the flush returns error?
2099          */
2100         rc = filemap_write_and_wait(inode->i_mapping);
2101         mapping_set_error(inode->i_mapping, rc);
2102         rc = 0;
2103
2104         if (attrs->ia_valid & ATTR_SIZE) {
2105                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2106                 if (rc != 0)
2107                         goto cifs_setattr_exit;
2108         }
2109
2110         /*
2111          * Without unix extensions we can't send ownership changes to the
2112          * server, so silently ignore them. This is consistent with how
2113          * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
2114          * CIFSACL support + proper Windows to Unix idmapping, we may be
2115          * able to support this in the future.
2116          */
2117         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2118                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2119
2120         /* skip mode change if it's just for clearing setuid/setgid */
2121         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2122                 attrs->ia_valid &= ~ATTR_MODE;
2123
2124         if (attrs->ia_valid & ATTR_MODE) {
2125                 cFYI(1, "Mode changed to 0%o", attrs->ia_mode);
2126                 mode = attrs->ia_mode;
2127         }
2128
2129         if (attrs->ia_valid & ATTR_MODE) {
2130                 rc = 0;
2131 #ifdef CONFIG_CIFS_ACL
2132                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2133                         rc = mode_to_cifs_acl(inode, full_path, mode);
2134                         if (rc) {
2135                                 cFYI(1, "%s: Setting ACL failed with error: %d",
2136                                         __func__, rc);
2137                                 goto cifs_setattr_exit;
2138                         }
2139                 } else
2140 #endif /* CONFIG_CIFS_ACL */
2141                 if (((mode & S_IWUGO) == 0) &&
2142                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2143
2144                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2145
2146                         /* fix up mode if we're not using dynperm */
2147                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2148                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2149                 } else if ((mode & S_IWUGO) &&
2150                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2151
2152                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2153                         /* Attributes of 0 are ignored */
2154                         if (dosattr == 0)
2155                                 dosattr |= ATTR_NORMAL;
2156
2157                         /* reset local inode permissions to normal */
2158                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2159                                 attrs->ia_mode &= ~(S_IALLUGO);
2160                                 if (S_ISDIR(inode->i_mode))
2161                                         attrs->ia_mode |=
2162                                                 cifs_sb->mnt_dir_mode;
2163                                 else
2164                                         attrs->ia_mode |=
2165                                                 cifs_sb->mnt_file_mode;
2166                         }
2167                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2168                         /* ignore mode change - ATTR_READONLY hasn't changed */
2169                         attrs->ia_valid &= ~ATTR_MODE;
2170                 }
2171         }
2172
2173         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2174             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2175                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2176                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2177
2178                 /* Even if error on time set, no sense failing the call if
2179                 the server would set the time to a reasonable value anyway,
2180                 and this check ensures that we are not being called from
2181                 sys_utimes in which case we ought to fail the call back to
2182                 the user when the server rejects the call */
2183                 if ((rc) && (attrs->ia_valid &
2184                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2185                         rc = 0;
2186         }
2187
2188         /* do not need local check to inode_check_ok since the server does
2189            that */
2190         if (rc)
2191                 goto cifs_setattr_exit;
2192
2193         if ((attrs->ia_valid & ATTR_SIZE) &&
2194             attrs->ia_size != i_size_read(inode))
2195                 truncate_setsize(inode, attrs->ia_size);
2196
2197         setattr_copy(inode, attrs);
2198         mark_inode_dirty(inode);
2199
2200 cifs_setattr_exit:
2201         kfree(full_path);
2202         FreeXid(xid);
2203         return rc;
2204 }
2205
2206 int
2207 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2208 {
2209         struct inode *inode = direntry->d_inode;
2210         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2211         struct cifsTconInfo *pTcon = cifs_sb_master_tcon(cifs_sb);
2212
2213         if (pTcon->unix_ext)
2214                 return cifs_setattr_unix(direntry, attrs);
2215
2216         return cifs_setattr_nounix(direntry, attrs);
2217
2218         /* BB: add cifs_setattr_legacy for really old servers */
2219 }
2220
2221 #if 0
2222 void cifs_delete_inode(struct inode *inode)
2223 {
2224         cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2225         /* may have to add back in if and when safe distributed caching of
2226            directories added e.g. via FindNotify */
2227 }
2228 #endif