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 cifs_rename_exit:
1642         kfree(info_buf_source);
1643         kfree(fromName);
1644         kfree(toName);
1645         FreeXid(xid);
1646         cifs_put_tlink(tlink);
1647         return rc;
1648 }
1649
1650 static bool
1651 cifs_inode_needs_reval(struct inode *inode)
1652 {
1653         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1654         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1655
1656         if (cifs_i->clientCanCacheRead)
1657                 return false;
1658
1659         if (!lookupCacheEnabled)
1660                 return true;
1661
1662         if (cifs_i->time == 0)
1663                 return true;
1664
1665         if (!time_in_range(jiffies, cifs_i->time,
1666                                 cifs_i->time + cifs_sb->actimeo))
1667                 return true;
1668
1669         /* hardlinked files w/ noserverino get "special" treatment */
1670         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1671             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1672                 return true;
1673
1674         return false;
1675 }
1676
1677 /*
1678  * Zap the cache. Called when invalid_mapping flag is set.
1679  */
1680 int
1681 cifs_invalidate_mapping(struct inode *inode)
1682 {
1683         int rc = 0;
1684         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1685
1686         cifs_i->invalid_mapping = false;
1687
1688         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1689                 rc = invalidate_inode_pages2(inode->i_mapping);
1690                 if (rc) {
1691                         cERROR(1, "%s: could not invalidate inode %p", __func__,
1692                                inode);
1693                         cifs_i->invalid_mapping = true;
1694                 }
1695         }
1696
1697         cifs_fscache_reset_inode_cookie(inode);
1698         return rc;
1699 }
1700
1701 int cifs_revalidate_file_attr(struct file *filp)
1702 {
1703         int rc = 0;
1704         struct inode *inode = filp->f_path.dentry->d_inode;
1705         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1706
1707         if (!cifs_inode_needs_reval(inode))
1708                 return rc;
1709
1710         if (tlink_tcon(cfile->tlink)->unix_ext)
1711                 rc = cifs_get_file_info_unix(filp);
1712         else
1713                 rc = cifs_get_file_info(filp);
1714
1715         return rc;
1716 }
1717
1718 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1719 {
1720         int xid;
1721         int rc = 0;
1722         struct inode *inode = dentry->d_inode;
1723         struct super_block *sb = dentry->d_sb;
1724         char *full_path = NULL;
1725
1726         if (inode == NULL)
1727                 return -ENOENT;
1728
1729         if (!cifs_inode_needs_reval(inode))
1730                 return rc;
1731
1732         xid = GetXid();
1733
1734         /* can not safely grab the rename sem here if rename calls revalidate
1735            since that would deadlock */
1736         full_path = build_path_from_dentry(dentry);
1737         if (full_path == NULL) {
1738                 rc = -ENOMEM;
1739                 goto out;
1740         }
1741
1742         cFYI(1, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time "
1743                  "%ld jiffies %ld", full_path, inode, inode->i_count.counter,
1744                  dentry, dentry->d_time, jiffies);
1745
1746         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1747                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1748         else
1749                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1750                                          xid, NULL);
1751
1752 out:
1753         kfree(full_path);
1754         FreeXid(xid);
1755         return rc;
1756 }
1757
1758 int cifs_revalidate_file(struct file *filp)
1759 {
1760         int rc;
1761         struct inode *inode = filp->f_path.dentry->d_inode;
1762
1763         rc = cifs_revalidate_file_attr(filp);
1764         if (rc)
1765                 return rc;
1766
1767         if (CIFS_I(inode)->invalid_mapping)
1768                 rc = cifs_invalidate_mapping(inode);
1769         return rc;
1770 }
1771
1772 /* revalidate a dentry's inode attributes */
1773 int cifs_revalidate_dentry(struct dentry *dentry)
1774 {
1775         int rc;
1776         struct inode *inode = dentry->d_inode;
1777
1778         rc = cifs_revalidate_dentry_attr(dentry);
1779         if (rc)
1780                 return rc;
1781
1782         if (CIFS_I(inode)->invalid_mapping)
1783                 rc = cifs_invalidate_mapping(inode);
1784         return rc;
1785 }
1786
1787 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1788                  struct kstat *stat)
1789 {
1790         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1791         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1792         struct inode *inode = dentry->d_inode;
1793         int rc;
1794
1795         /*
1796          * We need to be sure that all dirty pages are written and the server
1797          * has actual ctime, mtime and file length.
1798          */
1799         if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1800             inode->i_mapping->nrpages != 0) {
1801                 rc = filemap_fdatawait(inode->i_mapping);
1802                 if (rc) {
1803                         mapping_set_error(inode->i_mapping, rc);
1804                         return rc;
1805                 }
1806         }
1807
1808         rc = cifs_revalidate_dentry_attr(dentry);
1809         if (rc)
1810                 return rc;
1811
1812         generic_fillattr(inode, stat);
1813         stat->blksize = CIFS_MAX_MSGSIZE;
1814         stat->ino = CIFS_I(inode)->uniqueid;
1815
1816         /*
1817          * If on a multiuser mount without unix extensions, and the admin hasn't
1818          * overridden them, set the ownership to the fsuid/fsgid of the current
1819          * process.
1820          */
1821         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1822             !tcon->unix_ext) {
1823                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1824                         stat->uid = current_fsuid();
1825                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1826                         stat->gid = current_fsgid();
1827         }
1828         return rc;
1829 }
1830
1831 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1832 {
1833         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1834         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1835         struct page *page;
1836         int rc = 0;
1837
1838         page = grab_cache_page(mapping, index);
1839         if (!page)
1840                 return -ENOMEM;
1841
1842         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1843         unlock_page(page);
1844         page_cache_release(page);
1845         return rc;
1846 }
1847
1848 static void cifs_setsize(struct inode *inode, loff_t offset)
1849 {
1850         loff_t oldsize;
1851
1852         spin_lock(&inode->i_lock);
1853         oldsize = inode->i_size;
1854         i_size_write(inode, offset);
1855         spin_unlock(&inode->i_lock);
1856
1857         truncate_pagecache(inode, oldsize, offset);
1858 }
1859
1860 static int
1861 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1862                    int xid, char *full_path)
1863 {
1864         int rc;
1865         struct cifsFileInfo *open_file;
1866         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1867         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1868         struct tcon_link *tlink = NULL;
1869         struct cifs_tcon *pTcon = NULL;
1870         struct cifs_io_parms io_parms;
1871
1872         /*
1873          * To avoid spurious oplock breaks from server, in the case of
1874          * inodes that we already have open, avoid doing path based
1875          * setting of file size if we can do it by handle.
1876          * This keeps our caching token (oplock) and avoids timeouts
1877          * when the local oplock break takes longer to flush
1878          * writebehind data than the SMB timeout for the SetPathInfo
1879          * request would allow
1880          */
1881         open_file = find_writable_file(cifsInode, true);
1882         if (open_file) {
1883                 __u16 nfid = open_file->netfid;
1884                 __u32 npid = open_file->pid;
1885                 pTcon = tlink_tcon(open_file->tlink);
1886                 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1887                                         npid, false);
1888                 cifsFileInfo_put(open_file);
1889                 cFYI(1, "SetFSize for attrs rc = %d", rc);
1890                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1891                         unsigned int bytes_written;
1892
1893                         io_parms.netfid = nfid;
1894                         io_parms.pid = npid;
1895                         io_parms.tcon = pTcon;
1896                         io_parms.offset = 0;
1897                         io_parms.length = attrs->ia_size;
1898                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1899                                           NULL, NULL, 1);
1900                         cFYI(1, "Wrt seteof rc %d", rc);
1901                 }
1902         } else
1903                 rc = -EINVAL;
1904
1905         if (rc != 0) {
1906                 if (pTcon == NULL) {
1907                         tlink = cifs_sb_tlink(cifs_sb);
1908                         if (IS_ERR(tlink))
1909                                 return PTR_ERR(tlink);
1910                         pTcon = tlink_tcon(tlink);
1911                 }
1912
1913                 /* Set file size by pathname rather than by handle
1914                    either because no valid, writeable file handle for
1915                    it was found or because there was an error setting
1916                    it by handle */
1917                 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1918                                    false, cifs_sb->local_nls,
1919                                    cifs_sb->mnt_cifs_flags &
1920                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1921                 cFYI(1, "SetEOF by path (setattrs) rc = %d", rc);
1922                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1923                         __u16 netfid;
1924                         int oplock = 0;
1925
1926                         rc = SMBLegacyOpen(xid, pTcon, full_path,
1927                                 FILE_OPEN, GENERIC_WRITE,
1928                                 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1929                                 cifs_sb->local_nls,
1930                                 cifs_sb->mnt_cifs_flags &
1931                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1932                         if (rc == 0) {
1933                                 unsigned int bytes_written;
1934
1935                                 io_parms.netfid = netfid;
1936                                 io_parms.pid = current->tgid;
1937                                 io_parms.tcon = pTcon;
1938                                 io_parms.offset = 0;
1939                                 io_parms.length = attrs->ia_size;
1940                                 rc = CIFSSMBWrite(xid, &io_parms,
1941                                                   &bytes_written,
1942                                                   NULL, NULL,  1);
1943                                 cFYI(1, "wrt seteof rc %d", rc);
1944                                 CIFSSMBClose(xid, pTcon, netfid);
1945                         }
1946                 }
1947                 if (tlink)
1948                         cifs_put_tlink(tlink);
1949         }
1950
1951         if (rc == 0) {
1952                 cifsInode->server_eof = attrs->ia_size;
1953                 cifs_setsize(inode, attrs->ia_size);
1954                 cifs_truncate_page(inode->i_mapping, inode->i_size);
1955         }
1956
1957         return rc;
1958 }
1959
1960 static int
1961 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1962 {
1963         int rc;
1964         int xid;
1965         char *full_path = NULL;
1966         struct inode *inode = direntry->d_inode;
1967         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1968         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1969         struct tcon_link *tlink;
1970         struct cifs_tcon *pTcon;
1971         struct cifs_unix_set_info_args *args = NULL;
1972         struct cifsFileInfo *open_file;
1973
1974         cFYI(1, "setattr_unix on file %s attrs->ia_valid=0x%x",
1975                  direntry->d_name.name, attrs->ia_valid);
1976
1977         xid = GetXid();
1978
1979         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
1980                 attrs->ia_valid |= ATTR_FORCE;
1981
1982         rc = inode_change_ok(inode, attrs);
1983         if (rc < 0)
1984                 goto out;
1985
1986         full_path = build_path_from_dentry(direntry);
1987         if (full_path == NULL) {
1988                 rc = -ENOMEM;
1989                 goto out;
1990         }
1991
1992         /*
1993          * Attempt to flush data before changing attributes. We need to do
1994          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
1995          * ownership or mode then we may also need to do this. Here, we take
1996          * the safe way out and just do the flush on all setattr requests. If
1997          * the flush returns error, store it to report later and continue.
1998          *
1999          * BB: This should be smarter. Why bother flushing pages that
2000          * will be truncated anyway? Also, should we error out here if
2001          * the flush returns error?
2002          */
2003         rc = filemap_write_and_wait(inode->i_mapping);
2004         mapping_set_error(inode->i_mapping, rc);
2005         rc = 0;
2006
2007         if (attrs->ia_valid & ATTR_SIZE) {
2008                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2009                 if (rc != 0)
2010                         goto out;
2011         }
2012
2013         /* skip mode change if it's just for clearing setuid/setgid */
2014         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2015                 attrs->ia_valid &= ~ATTR_MODE;
2016
2017         args = kmalloc(sizeof(*args), GFP_KERNEL);
2018         if (args == NULL) {
2019                 rc = -ENOMEM;
2020                 goto out;
2021         }
2022
2023         /* set up the struct */
2024         if (attrs->ia_valid & ATTR_MODE)
2025                 args->mode = attrs->ia_mode;
2026         else
2027                 args->mode = NO_CHANGE_64;
2028
2029         if (attrs->ia_valid & ATTR_UID)
2030                 args->uid = attrs->ia_uid;
2031         else
2032                 args->uid = NO_CHANGE_64;
2033
2034         if (attrs->ia_valid & ATTR_GID)
2035                 args->gid = attrs->ia_gid;
2036         else
2037                 args->gid = NO_CHANGE_64;
2038
2039         if (attrs->ia_valid & ATTR_ATIME)
2040                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2041         else
2042                 args->atime = NO_CHANGE_64;
2043
2044         if (attrs->ia_valid & ATTR_MTIME)
2045                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2046         else
2047                 args->mtime = NO_CHANGE_64;
2048
2049         if (attrs->ia_valid & ATTR_CTIME)
2050                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2051         else
2052                 args->ctime = NO_CHANGE_64;
2053
2054         args->device = 0;
2055         open_file = find_writable_file(cifsInode, true);
2056         if (open_file) {
2057                 u16 nfid = open_file->netfid;
2058                 u32 npid = open_file->pid;
2059                 pTcon = tlink_tcon(open_file->tlink);
2060                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2061                 cifsFileInfo_put(open_file);
2062         } else {
2063                 tlink = cifs_sb_tlink(cifs_sb);
2064                 if (IS_ERR(tlink)) {
2065                         rc = PTR_ERR(tlink);
2066                         goto out;
2067                 }
2068                 pTcon = tlink_tcon(tlink);
2069                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2070                                     cifs_sb->local_nls,
2071                                     cifs_sb->mnt_cifs_flags &
2072                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
2073                 cifs_put_tlink(tlink);
2074         }
2075
2076         if (rc)
2077                 goto out;
2078
2079         if ((attrs->ia_valid & ATTR_SIZE) &&
2080             attrs->ia_size != i_size_read(inode))
2081                 truncate_setsize(inode, attrs->ia_size);
2082
2083         setattr_copy(inode, attrs);
2084         mark_inode_dirty(inode);
2085
2086         /* force revalidate when any of these times are set since some
2087            of the fs types (eg ext3, fat) do not have fine enough
2088            time granularity to match protocol, and we do not have a
2089            a way (yet) to query the server fs's time granularity (and
2090            whether it rounds times down).
2091         */
2092         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2093                 cifsInode->time = 0;
2094 out:
2095         kfree(args);
2096         kfree(full_path);
2097         FreeXid(xid);
2098         return rc;
2099 }
2100
2101 static int
2102 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2103 {
2104         int xid;
2105         uid_t uid = NO_CHANGE_32;
2106         gid_t gid = NO_CHANGE_32;
2107         struct inode *inode = direntry->d_inode;
2108         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2109         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2110         char *full_path = NULL;
2111         int rc = -EACCES;
2112         __u32 dosattr = 0;
2113         __u64 mode = NO_CHANGE_64;
2114
2115         xid = GetXid();
2116
2117         cFYI(1, "setattr on file %s attrs->iavalid 0x%x",
2118                  direntry->d_name.name, attrs->ia_valid);
2119
2120         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2121                 attrs->ia_valid |= ATTR_FORCE;
2122
2123         rc = inode_change_ok(inode, attrs);
2124         if (rc < 0) {
2125                 FreeXid(xid);
2126                 return rc;
2127         }
2128
2129         full_path = build_path_from_dentry(direntry);
2130         if (full_path == NULL) {
2131                 rc = -ENOMEM;
2132                 FreeXid(xid);
2133                 return rc;
2134         }
2135
2136         /*
2137          * Attempt to flush data before changing attributes. We need to do
2138          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2139          * ownership or mode then we may also need to do this. Here, we take
2140          * the safe way out and just do the flush on all setattr requests. If
2141          * the flush returns error, store it to report later and continue.
2142          *
2143          * BB: This should be smarter. Why bother flushing pages that
2144          * will be truncated anyway? Also, should we error out here if
2145          * the flush returns error?
2146          */
2147         rc = filemap_write_and_wait(inode->i_mapping);
2148         mapping_set_error(inode->i_mapping, rc);
2149         rc = 0;
2150
2151         if (attrs->ia_valid & ATTR_SIZE) {
2152                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2153                 if (rc != 0)
2154                         goto cifs_setattr_exit;
2155         }
2156
2157         if (attrs->ia_valid & ATTR_UID)
2158                 uid = attrs->ia_uid;
2159
2160         if (attrs->ia_valid & ATTR_GID)
2161                 gid = attrs->ia_gid;
2162
2163 #ifdef CONFIG_CIFS_ACL
2164         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2165                 if (uid != NO_CHANGE_32 || gid != NO_CHANGE_32) {
2166                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2167                                                         uid, gid);
2168                         if (rc) {
2169                                 cFYI(1, "%s: Setting id failed with error: %d",
2170                                         __func__, rc);
2171                                 goto cifs_setattr_exit;
2172                         }
2173                 }
2174         } else
2175 #endif /* CONFIG_CIFS_ACL */
2176         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2177                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2178
2179         /* skip mode change if it's just for clearing setuid/setgid */
2180         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2181                 attrs->ia_valid &= ~ATTR_MODE;
2182
2183         if (attrs->ia_valid & ATTR_MODE) {
2184                 mode = attrs->ia_mode;
2185                 rc = 0;
2186 #ifdef CONFIG_CIFS_ACL
2187                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2188                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2189                                                 NO_CHANGE_32, NO_CHANGE_32);
2190                         if (rc) {
2191                                 cFYI(1, "%s: Setting ACL failed with error: %d",
2192                                         __func__, rc);
2193                                 goto cifs_setattr_exit;
2194                         }
2195                 } else
2196 #endif /* CONFIG_CIFS_ACL */
2197                 if (((mode & S_IWUGO) == 0) &&
2198                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2199
2200                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2201
2202                         /* fix up mode if we're not using dynperm */
2203                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2204                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2205                 } else if ((mode & S_IWUGO) &&
2206                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2207
2208                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2209                         /* Attributes of 0 are ignored */
2210                         if (dosattr == 0)
2211                                 dosattr |= ATTR_NORMAL;
2212
2213                         /* reset local inode permissions to normal */
2214                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2215                                 attrs->ia_mode &= ~(S_IALLUGO);
2216                                 if (S_ISDIR(inode->i_mode))
2217                                         attrs->ia_mode |=
2218                                                 cifs_sb->mnt_dir_mode;
2219                                 else
2220                                         attrs->ia_mode |=
2221                                                 cifs_sb->mnt_file_mode;
2222                         }
2223                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2224                         /* ignore mode change - ATTR_READONLY hasn't changed */
2225                         attrs->ia_valid &= ~ATTR_MODE;
2226                 }
2227         }
2228
2229         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2230             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2231                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2232                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2233
2234                 /* Even if error on time set, no sense failing the call if
2235                 the server would set the time to a reasonable value anyway,
2236                 and this check ensures that we are not being called from
2237                 sys_utimes in which case we ought to fail the call back to
2238                 the user when the server rejects the call */
2239                 if ((rc) && (attrs->ia_valid &
2240                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2241                         rc = 0;
2242         }
2243
2244         /* do not need local check to inode_check_ok since the server does
2245            that */
2246         if (rc)
2247                 goto cifs_setattr_exit;
2248
2249         if ((attrs->ia_valid & ATTR_SIZE) &&
2250             attrs->ia_size != i_size_read(inode))
2251                 truncate_setsize(inode, attrs->ia_size);
2252
2253         setattr_copy(inode, attrs);
2254         mark_inode_dirty(inode);
2255
2256 cifs_setattr_exit:
2257         kfree(full_path);
2258         FreeXid(xid);
2259         return rc;
2260 }
2261
2262 int
2263 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2264 {
2265         struct inode *inode = direntry->d_inode;
2266         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2267         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2268
2269         if (pTcon->unix_ext)
2270                 return cifs_setattr_unix(direntry, attrs);
2271
2272         return cifs_setattr_nounix(direntry, attrs);
2273
2274         /* BB: add cifs_setattr_legacy for really old servers */
2275 }
2276
2277 #if 0
2278 void cifs_delete_inode(struct inode *inode)
2279 {
2280         cFYI(1, "In cifs_delete_inode, inode = 0x%p", inode);
2281         /* may have to add back in if and when safe distributed caching of
2282            directories added e.g. via FindNotify */
2283 }
2284 #endif