fs/cifs/inode.c

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