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