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