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