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