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

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