fs/cifs/inode.c

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