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