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