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