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

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