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

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