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