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