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