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