Pileus Git - ~andy/linux/blob - fs/cifs/inode.c

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