fs/cifs/inode.c

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