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