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 (!time_in_range(jiffies, cifs_i->time,
1741                                 cifs_i->time + cifs_sb->actimeo))
1742                 return true;
1743
1744         /* hardlinked files w/ noserverino get "special" treatment */
1745         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1746             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1747                 return true;
1748
1749         return false;
1750 }
1751
1752 /*
1753  * Zap the cache. Called when invalid_mapping flag is set.
1754  */
1755 int
1756 cifs_invalidate_mapping(struct inode *inode)
1757 {
1758         int rc = 0;
1759         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1760
1761         cifs_i->invalid_mapping = false;
1762
1763         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1764                 rc = invalidate_inode_pages2(inode->i_mapping);
1765                 if (rc) {
1766                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1767                                  __func__, inode);
1768                         cifs_i->invalid_mapping = true;
1769                 }
1770         }
1771
1772         cifs_fscache_reset_inode_cookie(inode);
1773         return rc;
1774 }
1775
1776 int cifs_revalidate_file_attr(struct file *filp)
1777 {
1778         int rc = 0;
1779         struct inode *inode = file_inode(filp);
1780         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1781
1782         if (!cifs_inode_needs_reval(inode))
1783                 return rc;
1784
1785         if (tlink_tcon(cfile->tlink)->unix_ext)
1786                 rc = cifs_get_file_info_unix(filp);
1787         else
1788                 rc = cifs_get_file_info(filp);
1789
1790         return rc;
1791 }
1792
1793 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1794 {
1795         unsigned int xid;
1796         int rc = 0;
1797         struct inode *inode = dentry->d_inode;
1798         struct super_block *sb = dentry->d_sb;
1799         char *full_path = NULL;
1800
1801         if (inode == NULL)
1802                 return -ENOENT;
1803
1804         if (!cifs_inode_needs_reval(inode))
1805                 return rc;
1806
1807         xid = get_xid();
1808
1809         /* can not safely grab the rename sem here if rename calls revalidate
1810            since that would deadlock */
1811         full_path = build_path_from_dentry(dentry);
1812         if (full_path == NULL) {
1813                 rc = -ENOMEM;
1814                 goto out;
1815         }
1816
1817         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1818                  full_path, inode, inode->i_count.counter,
1819                  dentry, dentry->d_time, jiffies);
1820
1821         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1822                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1823         else
1824                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1825                                          xid, NULL);
1826
1827 out:
1828         kfree(full_path);
1829         free_xid(xid);
1830         return rc;
1831 }
1832
1833 int cifs_revalidate_file(struct file *filp)
1834 {
1835         int rc;
1836         struct inode *inode = file_inode(filp);
1837
1838         rc = cifs_revalidate_file_attr(filp);
1839         if (rc)
1840                 return rc;
1841
1842         if (CIFS_I(inode)->invalid_mapping)
1843                 rc = cifs_invalidate_mapping(inode);
1844         return rc;
1845 }
1846
1847 /* revalidate a dentry's inode attributes */
1848 int cifs_revalidate_dentry(struct dentry *dentry)
1849 {
1850         int rc;
1851         struct inode *inode = dentry->d_inode;
1852
1853         rc = cifs_revalidate_dentry_attr(dentry);
1854         if (rc)
1855                 return rc;
1856
1857         if (CIFS_I(inode)->invalid_mapping)
1858                 rc = cifs_invalidate_mapping(inode);
1859         return rc;
1860 }
1861
1862 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1863                  struct kstat *stat)
1864 {
1865         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1866         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1867         struct inode *inode = dentry->d_inode;
1868         int rc;
1869
1870         /*
1871          * We need to be sure that all dirty pages are written and the server
1872          * has actual ctime, mtime and file length.
1873          */
1874         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1875             inode->i_mapping->nrpages != 0) {
1876                 rc = filemap_fdatawait(inode->i_mapping);
1877                 if (rc) {
1878                         mapping_set_error(inode->i_mapping, rc);
1879                         return rc;
1880                 }
1881         }
1882
1883         rc = cifs_revalidate_dentry_attr(dentry);
1884         if (rc)
1885                 return rc;
1886
1887         generic_fillattr(inode, stat);
1888         stat->blksize = CIFS_MAX_MSGSIZE;
1889         stat->ino = CIFS_I(inode)->uniqueid;
1890
1891         /*
1892          * If on a multiuser mount without unix extensions or cifsacl being
1893          * enabled, and the admin hasn't overridden them, set the ownership
1894          * to the fsuid/fsgid of the current process.
1895          */
1896         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1897             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1898             !tcon->unix_ext) {
1899                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1900                         stat->uid = current_fsuid();
1901                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1902                         stat->gid = current_fsgid();
1903         }
1904         return rc;
1905 }
1906
1907 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1908 {
1909         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1910         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1911         struct page *page;
1912         int rc = 0;
1913
1914         page = grab_cache_page(mapping, index);
1915         if (!page)
1916                 return -ENOMEM;
1917
1918         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1919         unlock_page(page);
1920         page_cache_release(page);
1921         return rc;
1922 }
1923
1924 static void cifs_setsize(struct inode *inode, loff_t offset)
1925 {
1926         spin_lock(&inode->i_lock);
1927         i_size_write(inode, offset);
1928         spin_unlock(&inode->i_lock);
1929
1930         truncate_pagecache(inode, offset);
1931 }
1932
1933 static int
1934 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1935                    unsigned int xid, char *full_path)
1936 {
1937         int rc;
1938         struct cifsFileInfo *open_file;
1939         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1940         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1941         struct tcon_link *tlink = NULL;
1942         struct cifs_tcon *tcon = NULL;
1943         struct TCP_Server_Info *server;
1944         struct cifs_io_parms io_parms;
1945
1946         /*
1947          * To avoid spurious oplock breaks from server, in the case of
1948          * inodes that we already have open, avoid doing path based
1949          * setting of file size if we can do it by handle.
1950          * This keeps our caching token (oplock) and avoids timeouts
1951          * when the local oplock break takes longer to flush
1952          * writebehind data than the SMB timeout for the SetPathInfo
1953          * request would allow
1954          */
1955         open_file = find_writable_file(cifsInode, true);
1956         if (open_file) {
1957                 tcon = tlink_tcon(open_file->tlink);
1958                 server = tcon->ses->server;
1959                 if (server->ops->set_file_size)
1960                         rc = server->ops->set_file_size(xid, tcon, open_file,
1961                                                         attrs->ia_size, false);
1962                 else
1963                         rc = -ENOSYS;
1964                 cifsFileInfo_put(open_file);
1965                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1966                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1967                         unsigned int bytes_written;
1968
1969                         io_parms.netfid = open_file->fid.netfid;
1970                         io_parms.pid = open_file->pid;
1971                         io_parms.tcon = tcon;
1972                         io_parms.offset = 0;
1973                         io_parms.length = attrs->ia_size;
1974                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1975                                           NULL, NULL, 1);
1976                         cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1977                 }
1978         } else
1979                 rc = -EINVAL;
1980
1981         if (!rc)
1982                 goto set_size_out;
1983
1984         if (tcon == NULL) {
1985                 tlink = cifs_sb_tlink(cifs_sb);
1986                 if (IS_ERR(tlink))
1987                         return PTR_ERR(tlink);
1988                 tcon = tlink_tcon(tlink);
1989                 server = tcon->ses->server;
1990         }
1991
1992         /*
1993          * Set file size by pathname rather than by handle either because no
1994          * valid, writeable file handle for it was found or because there was
1995          * an error setting it by handle.
1996          */
1997         if (server->ops->set_path_size)
1998                 rc = server->ops->set_path_size(xid, tcon, full_path,
1999                                                 attrs->ia_size, cifs_sb, false);
2000         else
2001                 rc = -ENOSYS;
2002         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2003         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2004                 __u16 netfid;
2005                 int oplock = 0;
2006
2007                 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
2008                                    GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
2009                                    &oplock, NULL, cifs_sb->local_nls,
2010                                    cifs_sb->mnt_cifs_flags &
2011                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2012                 if (rc == 0) {
2013                         unsigned int bytes_written;
2014
2015                         io_parms.netfid = netfid;
2016                         io_parms.pid = current->tgid;
2017                         io_parms.tcon = tcon;
2018                         io_parms.offset = 0;
2019                         io_parms.length = attrs->ia_size;
2020                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
2021                                           NULL,  1);
2022                         cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
2023                         CIFSSMBClose(xid, tcon, netfid);
2024                 }
2025         }
2026         if (tlink)
2027                 cifs_put_tlink(tlink);
2028
2029 set_size_out:
2030         if (rc == 0) {
2031                 cifsInode->server_eof = attrs->ia_size;
2032                 cifs_setsize(inode, attrs->ia_size);
2033                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2034         }
2035
2036         return rc;
2037 }
2038
2039 static int
2040 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2041 {
2042         int rc;
2043         unsigned int xid;
2044         char *full_path = NULL;
2045         struct inode *inode = direntry->d_inode;
2046         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2047         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2048         struct tcon_link *tlink;
2049         struct cifs_tcon *pTcon;
2050         struct cifs_unix_set_info_args *args = NULL;
2051         struct cifsFileInfo *open_file;
2052
2053         cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2054                  direntry->d_name.name, attrs->ia_valid);
2055
2056         xid = get_xid();
2057
2058         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2059                 attrs->ia_valid |= ATTR_FORCE;
2060
2061         rc = inode_change_ok(inode, attrs);
2062         if (rc < 0)
2063                 goto out;
2064
2065         full_path = build_path_from_dentry(direntry);
2066         if (full_path == NULL) {
2067                 rc = -ENOMEM;
2068                 goto out;
2069         }
2070
2071         /*
2072          * Attempt to flush data before changing attributes. We need to do
2073          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2074          * ownership or mode then we may also need to do this. Here, we take
2075          * the safe way out and just do the flush on all setattr requests. If
2076          * the flush returns error, store it to report later and continue.
2077          *
2078          * BB: This should be smarter. Why bother flushing pages that
2079          * will be truncated anyway? Also, should we error out here if
2080          * the flush returns error?
2081          */
2082         rc = filemap_write_and_wait(inode->i_mapping);
2083         mapping_set_error(inode->i_mapping, rc);
2084         rc = 0;
2085
2086         if (attrs->ia_valid & ATTR_SIZE) {
2087                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2088                 if (rc != 0)
2089                         goto out;
2090         }
2091
2092         /* skip mode change if it's just for clearing setuid/setgid */
2093         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2094                 attrs->ia_valid &= ~ATTR_MODE;
2095
2096         args = kmalloc(sizeof(*args), GFP_KERNEL);
2097         if (args == NULL) {
2098                 rc = -ENOMEM;
2099                 goto out;
2100         }
2101
2102         /* set up the struct */
2103         if (attrs->ia_valid & ATTR_MODE)
2104                 args->mode = attrs->ia_mode;
2105         else
2106                 args->mode = NO_CHANGE_64;
2107
2108         if (attrs->ia_valid & ATTR_UID)
2109                 args->uid = attrs->ia_uid;
2110         else
2111                 args->uid = INVALID_UID; /* no change */
2112
2113         if (attrs->ia_valid & ATTR_GID)
2114                 args->gid = attrs->ia_gid;
2115         else
2116                 args->gid = INVALID_GID; /* no change */
2117
2118         if (attrs->ia_valid & ATTR_ATIME)
2119                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2120         else
2121                 args->atime = NO_CHANGE_64;
2122
2123         if (attrs->ia_valid & ATTR_MTIME)
2124                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2125         else
2126                 args->mtime = NO_CHANGE_64;
2127
2128         if (attrs->ia_valid & ATTR_CTIME)
2129                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2130         else
2131                 args->ctime = NO_CHANGE_64;
2132
2133         args->device = 0;
2134         open_file = find_writable_file(cifsInode, true);
2135         if (open_file) {
2136                 u16 nfid = open_file->fid.netfid;
2137                 u32 npid = open_file->pid;
2138                 pTcon = tlink_tcon(open_file->tlink);
2139                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2140                 cifsFileInfo_put(open_file);
2141         } else {
2142                 tlink = cifs_sb_tlink(cifs_sb);
2143                 if (IS_ERR(tlink)) {
2144                         rc = PTR_ERR(tlink);
2145                         goto out;
2146                 }
2147                 pTcon = tlink_tcon(tlink);
2148                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2149                                     cifs_sb->local_nls,
2150                                     cifs_sb->mnt_cifs_flags &
2151                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
2152                 cifs_put_tlink(tlink);
2153         }
2154
2155         if (rc)
2156                 goto out;
2157
2158         if ((attrs->ia_valid & ATTR_SIZE) &&
2159             attrs->ia_size != i_size_read(inode))
2160                 truncate_setsize(inode, attrs->ia_size);
2161
2162         setattr_copy(inode, attrs);
2163         mark_inode_dirty(inode);
2164
2165         /* force revalidate when any of these times are set since some
2166            of the fs types (eg ext3, fat) do not have fine enough
2167            time granularity to match protocol, and we do not have a
2168            a way (yet) to query the server fs's time granularity (and
2169            whether it rounds times down).
2170         */
2171         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2172                 cifsInode->time = 0;
2173 out:
2174         kfree(args);
2175         kfree(full_path);
2176         free_xid(xid);
2177         return rc;
2178 }
2179
2180 static int
2181 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2182 {
2183         unsigned int xid;
2184         kuid_t uid = INVALID_UID;
2185         kgid_t gid = INVALID_GID;
2186         struct inode *inode = direntry->d_inode;
2187         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2188         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2189         char *full_path = NULL;
2190         int rc = -EACCES;
2191         __u32 dosattr = 0;
2192         __u64 mode = NO_CHANGE_64;
2193
2194         xid = get_xid();
2195
2196         cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2197                  direntry->d_name.name, attrs->ia_valid);
2198
2199         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2200                 attrs->ia_valid |= ATTR_FORCE;
2201
2202         rc = inode_change_ok(inode, attrs);
2203         if (rc < 0) {
2204                 free_xid(xid);
2205                 return rc;
2206         }
2207
2208         full_path = build_path_from_dentry(direntry);
2209         if (full_path == NULL) {
2210                 rc = -ENOMEM;
2211                 free_xid(xid);
2212                 return rc;
2213         }
2214
2215         /*
2216          * Attempt to flush data before changing attributes. We need to do
2217          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2218          * ownership or mode then we may also need to do this. Here, we take
2219          * the safe way out and just do the flush on all setattr requests. If
2220          * the flush returns error, store it to report later and continue.
2221          *
2222          * BB: This should be smarter. Why bother flushing pages that
2223          * will be truncated anyway? Also, should we error out here if
2224          * the flush returns error?
2225          */
2226         rc = filemap_write_and_wait(inode->i_mapping);
2227         mapping_set_error(inode->i_mapping, rc);
2228         rc = 0;
2229
2230         if (attrs->ia_valid & ATTR_SIZE) {
2231                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2232                 if (rc != 0)
2233                         goto cifs_setattr_exit;
2234         }
2235
2236         if (attrs->ia_valid & ATTR_UID)
2237                 uid = attrs->ia_uid;
2238
2239         if (attrs->ia_valid & ATTR_GID)
2240                 gid = attrs->ia_gid;
2241
2242 #ifdef CONFIG_CIFS_ACL
2243         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2244                 if (uid_valid(uid) || gid_valid(gid)) {
2245                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2246                                                         uid, gid);
2247                         if (rc) {
2248                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2249                                          __func__, rc);
2250                                 goto cifs_setattr_exit;
2251                         }
2252                 }
2253         } else
2254 #endif /* CONFIG_CIFS_ACL */
2255         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2256                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2257
2258         /* skip mode change if it's just for clearing setuid/setgid */
2259         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2260                 attrs->ia_valid &= ~ATTR_MODE;
2261
2262         if (attrs->ia_valid & ATTR_MODE) {
2263                 mode = attrs->ia_mode;
2264                 rc = 0;
2265 #ifdef CONFIG_CIFS_ACL
2266                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2267                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2268                                                 INVALID_UID, INVALID_GID);
2269                         if (rc) {
2270                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2271                                          __func__, rc);
2272                                 goto cifs_setattr_exit;
2273                         }
2274                 } else
2275 #endif /* CONFIG_CIFS_ACL */
2276                 if (((mode & S_IWUGO) == 0) &&
2277                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2278
2279                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2280
2281                         /* fix up mode if we're not using dynperm */
2282                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2283                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2284                 } else if ((mode & S_IWUGO) &&
2285                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2286
2287                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2288                         /* Attributes of 0 are ignored */
2289                         if (dosattr == 0)
2290                                 dosattr |= ATTR_NORMAL;
2291
2292                         /* reset local inode permissions to normal */
2293                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2294                                 attrs->ia_mode &= ~(S_IALLUGO);
2295                                 if (S_ISDIR(inode->i_mode))
2296                                         attrs->ia_mode |=
2297                                                 cifs_sb->mnt_dir_mode;
2298                                 else
2299                                         attrs->ia_mode |=
2300                                                 cifs_sb->mnt_file_mode;
2301                         }
2302                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2303                         /* ignore mode change - ATTR_READONLY hasn't changed */
2304                         attrs->ia_valid &= ~ATTR_MODE;
2305                 }
2306         }
2307
2308         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2309             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2310                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2311                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2312
2313                 /* Even if error on time set, no sense failing the call if
2314                 the server would set the time to a reasonable value anyway,
2315                 and this check ensures that we are not being called from
2316                 sys_utimes in which case we ought to fail the call back to
2317                 the user when the server rejects the call */
2318                 if ((rc) && (attrs->ia_valid &
2319                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2320                         rc = 0;
2321         }
2322
2323         /* do not need local check to inode_check_ok since the server does
2324            that */
2325         if (rc)
2326                 goto cifs_setattr_exit;
2327
2328         if ((attrs->ia_valid & ATTR_SIZE) &&
2329             attrs->ia_size != i_size_read(inode))
2330                 truncate_setsize(inode, attrs->ia_size);
2331
2332         setattr_copy(inode, attrs);
2333         mark_inode_dirty(inode);
2334
2335 cifs_setattr_exit:
2336         kfree(full_path);
2337         free_xid(xid);
2338         return rc;
2339 }
2340
2341 int
2342 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2343 {
2344         struct inode *inode = direntry->d_inode;
2345         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2346         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2347
2348         if (pTcon->unix_ext)
2349                 return cifs_setattr_unix(direntry, attrs);
2350
2351         return cifs_setattr_nounix(direntry, attrs);
2352
2353         /* BB: add cifs_setattr_legacy for really old servers */
2354 }
2355
2356 #if 0
2357 void cifs_delete_inode(struct inode *inode)
2358 {
2359         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2360         /* may have to add back in if and when safe distributed caching of
2361            directories added e.g. via FindNotify */
2362 }
2363 #endif