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