fs/cifs/inode.c

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