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