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