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