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