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