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