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