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