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