fs/cifs/inode.c

   1 /*
   2  *   fs/cifs/inode.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2010
   5  *   Author(s): Steve French ([email protected])
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/stat.h>
  23 #include <linux/slab.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/freezer.h>
  26 #include <linux/sched/signal.h>
  27 #include <linux/wait_bit.h>
  28
  29 #include <asm/div64.h>
  30 #include "cifsfs.h"
  31 #include "cifspdu.h"
  32 #include "cifsglob.h"
  33 #include "cifsproto.h"
  34 #include "cifs_debug.h"
  35 #include "cifs_fs_sb.h"
  36 #include "cifs_unicode.h"
  37 #include "fscache.h"
  38
  39
  40 static void cifs_set_ops(struct inode *inode)
  41 {
  42         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  43
  44         switch (inode->i_mode & S_IFMT) {
  45         case S_IFREG:
  46                 inode->i_op = &cifs_file_inode_ops;
  47                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  48                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  49                                 inode->i_fop = &cifs_file_direct_nobrl_ops;
  50                         else
  51                                 inode->i_fop = &cifs_file_direct_ops;
  52                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  53                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  54                                 inode->i_fop = &cifs_file_strict_nobrl_ops;
  55                         else
  56                                 inode->i_fop = &cifs_file_strict_ops;
  57                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  58                         inode->i_fop = &cifs_file_nobrl_ops;
  59                 else { /* not direct, send byte range locks */
  60                         inode->i_fop = &cifs_file_ops;
  61                 }
  62
  63                 /* check if server can support readpages */
  64                 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
  65                                 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
  66                         inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  67                 else
  68                         inode->i_data.a_ops = &cifs_addr_ops;
  69                 break;
  70         case S_IFDIR:
  71 #ifdef CONFIG_CIFS_DFS_UPCALL
  72                 if (IS_AUTOMOUNT(inode)) {
  73                         inode->i_op = &cifs_dfs_referral_inode_operations;
  74                 } else {
  75 #else /* NO DFS support, treat as a directory */
  76                 {
  77 #endif
  78                         inode->i_op = &cifs_dir_inode_ops;
  79                         inode->i_fop = &cifs_dir_ops;
  80                 }
  81                 break;
  82         case S_IFLNK:
  83                 inode->i_op = &cifs_symlink_inode_ops;
  84                 break;
  85         default:
  86                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
  87                 break;
  88         }
  89 }
  90
  91 /* check inode attributes against fattr. If they don't match, tag the
  92  * inode for cache invalidation
  93  */
  94 static void
  95 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
  96 {
  97         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
  98
  99         cifs_dbg(FYI, "%s: revalidating inode %llu\n",
 100                  __func__, cifs_i->uniqueid);
 101
 102         if (inode->i_state & I_NEW) {
 103                 cifs_dbg(FYI, "%s: inode %llu is new\n",
 104                          __func__, cifs_i->uniqueid);
 105                 return;
 106         }
 107
 108         /* don't bother with revalidation if we have an oplock */
 109         if (CIFS_CACHE_READ(cifs_i)) {
 110                 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
 111                          __func__, cifs_i->uniqueid);
 112                 return;
 113         }
 114
 115          /* revalidate if mtime or size have changed */
 116         if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
 117             cifs_i->server_eof == fattr->cf_eof) {
 118                 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
 119                          __func__, cifs_i->uniqueid);
 120                 return;
 121         }
 122
 123         cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 124                  __func__, cifs_i->uniqueid);
 125         set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
 126 }
 127
 128 /*
 129  * copy nlink to the inode, unless it wasn't provided.  Provide
 130  * sane values if we don't have an existing one and none was provided
 131  */
 132 static void
 133 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 134 {
 135         /*
 136          * if we're in a situation where we can't trust what we
 137          * got from the server (readdir, some non-unix cases)
 138          * fake reasonable values
 139          */
 140         if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
 141                 /* only provide fake values on a new inode */
 142                 if (inode->i_state & I_NEW) {
 143                         if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
 144                                 set_nlink(inode, 2);
 145                         else
 146                                 set_nlink(inode, 1);
 147                 }
 148                 return;
 149         }
 150
 151         /* we trust the server, so update it */
 152         set_nlink(inode, fattr->cf_nlink);
 153 }
 154
 155 /* populate an inode with info from a cifs_fattr struct */
 156 void
 157 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 158 {
 159         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 160         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 161
 162         cifs_revalidate_cache(inode, fattr);
 163
 164         spin_lock(&inode->i_lock);
 165         /* 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         /* fill in 0777 bits from ACL */
 896         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 897                 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
 898                 if (rc) {
 899                         cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
 900                                  __func__, rc);
 901                         goto cgii_exit;
 902                 }
 903         }
 904
 905         /* fill in remaining high mode bits e.g. SUID, VTX */
 906         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
 907                 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
 908
 909         /* check for Minshall+French symlinks */
 910         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 911                 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
 912                                          full_path);
 913                 if (tmprc)
 914                         cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
 915         }
 916
 917         if (!*inode) {
 918                 *inode = cifs_iget(sb, &fattr);
 919                 if (!*inode)
 920                         rc = -ENOMEM;
 921         } else {
 922                 /* we already have inode, update it */
 923
 924                 /* if uniqueid is different, return error */
 925                 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 926                     CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
 927                         rc = -ESTALE;
 928                         goto cgii_exit;
 929                 }
 930
 931                 /* if filetype is different, return error */
 932                 if (unlikely(((*inode)->i_mode & S_IFMT) !=
 933                     (fattr.cf_mode & S_IFMT))) {
 934                         rc = -ESTALE;
 935                         goto cgii_exit;
 936                 }
 937
 938                 cifs_fattr_to_inode(*inode, &fattr);
 939         }
 940
 941 cgii_exit:
 942         if ((*inode) && ((*inode)->i_ino == 0))
 943                 cifs_dbg(FYI, "inode number of zero returned\n");
 944
 945         kfree(buf);
 946         cifs_put_tlink(tlink);
 947         return rc;
 948 }
 949
 950 static const struct inode_operations cifs_ipc_inode_ops = {
 951         .lookup = cifs_lookup,
 952 };
 953
 954 static int
 955 cifs_find_inode(struct inode *inode, void *opaque)
 956 {
 957         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 958
 959         /* don't match inode with different uniqueid */
 960         if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
 961                 return 0;
 962
 963         /* use createtime like an i_generation field */
 964         if (CIFS_I(inode)->createtime != fattr->cf_createtime)
 965                 return 0;
 966
 967         /* don't match inode of different type */
 968         if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
 969                 return 0;
 970
 971         /* if it's not a directory or has no dentries, then flag it */
 972         if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
 973                 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
 974
 975         return 1;
 976 }
 977
 978 static int
 979 cifs_init_inode(struct inode *inode, void *opaque)
 980 {
 981         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
 982
 983         CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
 984         CIFS_I(inode)->createtime = fattr->cf_createtime;
 985         return 0;
 986 }
 987
 988 /*
 989  * walk dentry list for an inode and report whether it has aliases that
 990  * are hashed. We use this to determine if a directory inode can actually
 991  * be used.
 992  */
 993 static bool
 994 inode_has_hashed_dentries(struct inode *inode)
 995 {
 996         struct dentry *dentry;
 997
 998         spin_lock(&inode->i_lock);
 999         hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1000                 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1001                         spin_unlock(&inode->i_lock);
1002                         return true;
1003                 }
1004         }
1005         spin_unlock(&inode->i_lock);
1006         return false;
1007 }
1008
1009 /* Given fattrs, get a corresponding inode */
1010 struct inode *
1011 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1012 {
1013         unsigned long hash;
1014         struct inode *inode;
1015
1016 retry_iget5_locked:
1017         cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1018
1019         /* hash down to 32-bits on 32-bit arch */
1020         hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1021
1022         inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1023         if (inode) {
1024                 /* was there a potentially problematic inode collision? */
1025                 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1026                         fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1027
1028                         if (inode_has_hashed_dentries(inode)) {
1029                                 cifs_autodisable_serverino(CIFS_SB(sb));
1030                                 iput(inode);
1031                                 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1032                                 goto retry_iget5_locked;
1033                         }
1034                 }
1035
1036                 cifs_fattr_to_inode(inode, fattr);
1037                 if (sb->s_flags & SB_NOATIME)
1038                         inode->i_flags |= S_NOATIME | S_NOCMTIME;
1039                 if (inode->i_state & I_NEW) {
1040                         inode->i_ino = hash;
1041 #ifdef CONFIG_CIFS_FSCACHE
1042                         /* initialize per-inode cache cookie pointer */
1043                         CIFS_I(inode)->fscache = NULL;
1044 #endif
1045                         unlock_new_inode(inode);
1046                 }
1047         }
1048
1049         return inode;
1050 }
1051
1052 /* gets root inode */
1053 struct inode *cifs_root_iget(struct super_block *sb)
1054 {
1055         unsigned int xid;
1056         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1057         struct inode *inode = NULL;
1058         long rc;
1059         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1060         char *path = NULL;
1061         int len;
1062
1063         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1064             && cifs_sb->prepath) {
1065                 len = strlen(cifs_sb->prepath);
1066                 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1067                 if (path == NULL)
1068                         return ERR_PTR(-ENOMEM);
1069                 path[0] = '/';
1070                 memcpy(path+1, cifs_sb->prepath, len);
1071         } else {
1072                 path = kstrdup("", GFP_KERNEL);
1073                 if (path == NULL)
1074                         return ERR_PTR(-ENOMEM);
1075         }
1076
1077         xid = get_xid();
1078         if (tcon->unix_ext) {
1079                 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1080                 /* some servers mistakenly claim POSIX support */
1081                 if (rc != -EOPNOTSUPP)
1082                         goto iget_no_retry;
1083                 cifs_dbg(VFS, "server does not support POSIX extensions");
1084                 tcon->unix_ext = false;
1085         }
1086
1087         convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1088         rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1089
1090 iget_no_retry:
1091         if (!inode) {
1092                 inode = ERR_PTR(rc);
1093                 goto out;
1094         }
1095
1096 #ifdef CONFIG_CIFS_FSCACHE
1097         /* populate tcon->resource_id */
1098         tcon->resource_id = CIFS_I(inode)->uniqueid;
1099 #endif
1100
1101         if (rc && tcon->pipe) {
1102                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1103                 spin_lock(&inode->i_lock);
1104                 inode->i_mode |= S_IFDIR;
1105                 set_nlink(inode, 2);
1106                 inode->i_op = &cifs_ipc_inode_ops;
1107                 inode->i_fop = &simple_dir_operations;
1108                 inode->i_uid = cifs_sb->mnt_uid;
1109                 inode->i_gid = cifs_sb->mnt_gid;
1110                 spin_unlock(&inode->i_lock);
1111         } else if (rc) {
1112                 iget_failed(inode);
1113                 inode = ERR_PTR(rc);
1114         }
1115
1116 out:
1117         kfree(path);
1118         free_xid(xid);
1119         return inode;
1120 }
1121
1122 int
1123 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1124                    char *full_path, __u32 dosattr)
1125 {
1126         bool set_time = false;
1127         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1128         struct TCP_Server_Info *server;
1129         FILE_BASIC_INFO info_buf;
1130
1131         if (attrs == NULL)
1132                 return -EINVAL;
1133
1134         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1135         if (!server->ops->set_file_info)
1136                 return -ENOSYS;
1137
1138         info_buf.Pad = 0;
1139
1140         if (attrs->ia_valid & ATTR_ATIME) {
1141                 set_time = true;
1142                 info_buf.LastAccessTime =
1143                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1144         } else
1145                 info_buf.LastAccessTime = 0;
1146
1147         if (attrs->ia_valid & ATTR_MTIME) {
1148                 set_time = true;
1149                 info_buf.LastWriteTime =
1150                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1151         } else
1152                 info_buf.LastWriteTime = 0;
1153
1154         /*
1155          * Samba throws this field away, but windows may actually use it.
1156          * Do not set ctime unless other time stamps are changed explicitly
1157          * (i.e. by utimes()) since we would then have a mix of client and
1158          * server times.
1159          */
1160         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1161                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1162                 info_buf.ChangeTime =
1163                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1164         } else
1165                 info_buf.ChangeTime = 0;
1166
1167         info_buf.CreationTime = 0;      /* don't change */
1168         info_buf.Attributes = cpu_to_le32(dosattr);
1169
1170         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1171 }
1172
1173 /*
1174  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1175  * and rename it to a random name that hopefully won't conflict with
1176  * anything else.
1177  */
1178 int
1179 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1180                            const unsigned int xid)
1181 {
1182         int oplock = 0;
1183         int rc;
1184         struct cifs_fid fid;
1185         struct cifs_open_parms oparms;
1186         struct inode *inode = d_inode(dentry);
1187         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1188         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1189         struct tcon_link *tlink;
1190         struct cifs_tcon *tcon;
1191         __u32 dosattr, origattr;
1192         FILE_BASIC_INFO *info_buf = NULL;
1193
1194         tlink = cifs_sb_tlink(cifs_sb);
1195         if (IS_ERR(tlink))
1196                 return PTR_ERR(tlink);
1197         tcon = tlink_tcon(tlink);
1198
1199         /*
1200          * We cannot rename the file if the server doesn't support
1201          * CAP_INFOLEVEL_PASSTHRU
1202          */
1203         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1204                 rc = -EBUSY;
1205                 goto out;
1206         }
1207
1208         oparms.tcon = tcon;
1209         oparms.cifs_sb = cifs_sb;
1210         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1211         oparms.create_options = CREATE_NOT_DIR;
1212         oparms.disposition = FILE_OPEN;
1213         oparms.path = full_path;
1214         oparms.fid = &fid;
1215         oparms.reconnect = false;
1216
1217         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1218         if (rc != 0)
1219                 goto out;
1220
1221         origattr = cifsInode->cifsAttrs;
1222         if (origattr == 0)
1223                 origattr |= ATTR_NORMAL;
1224
1225         dosattr = origattr & ~ATTR_READONLY;
1226         if (dosattr == 0)
1227                 dosattr |= ATTR_NORMAL;
1228         dosattr |= ATTR_HIDDEN;
1229
1230         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1231         if (dosattr != origattr) {
1232                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1233                 if (info_buf == NULL) {
1234                         rc = -ENOMEM;
1235                         goto out_close;
1236                 }
1237                 info_buf->Attributes = cpu_to_le32(dosattr);
1238                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1239                                         current->tgid);
1240                 /* although we would like to mark the file hidden
1241                    if that fails we will still try to rename it */
1242                 if (!rc)
1243                         cifsInode->cifsAttrs = dosattr;
1244                 else
1245                         dosattr = origattr; /* since not able to change them */
1246         }
1247
1248         /* rename the file */
1249         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1250                                    cifs_sb->local_nls,
1251                                    cifs_remap(cifs_sb));
1252         if (rc != 0) {
1253                 rc = -EBUSY;
1254                 goto undo_setattr;
1255         }
1256
1257         /* try to set DELETE_ON_CLOSE */
1258         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1259                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1260                                                current->tgid);
1261                 /*
1262                  * some samba versions return -ENOENT when we try to set the
1263                  * file disposition here. Likely a samba bug, but work around
1264                  * it for now. This means that some cifsXXX files may hang
1265                  * around after they shouldn't.
1266                  *
1267                  * BB: remove this hack after more servers have the fix
1268                  */
1269                 if (rc == -ENOENT)
1270                         rc = 0;
1271                 else if (rc != 0) {
1272                         rc = -EBUSY;
1273                         goto undo_rename;
1274                 }
1275                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1276         }
1277
1278 out_close:
1279         CIFSSMBClose(xid, tcon, fid.netfid);
1280 out:
1281         kfree(info_buf);
1282         cifs_put_tlink(tlink);
1283         return rc;
1284
1285         /*
1286          * reset everything back to the original state. Don't bother
1287          * dealing with errors here since we can't do anything about
1288          * them anyway.
1289          */
1290 undo_rename:
1291         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1292                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1293 undo_setattr:
1294         if (dosattr != origattr) {
1295                 info_buf->Attributes = cpu_to_le32(origattr);
1296                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1297                                         current->tgid))
1298                         cifsInode->cifsAttrs = origattr;
1299         }
1300
1301         goto out_close;
1302 }
1303
1304 /* copied from fs/nfs/dir.c with small changes */
1305 static void
1306 cifs_drop_nlink(struct inode *inode)
1307 {
1308         spin_lock(&inode->i_lock);
1309         if (inode->i_nlink > 0)
1310                 drop_nlink(inode);
1311         spin_unlock(&inode->i_lock);
1312 }
1313
1314 /*
1315  * If d_inode(dentry) is null (usually meaning the cached dentry
1316  * is a negative dentry) then we would attempt a standard SMB delete, but
1317  * if that fails we can not attempt the fall back mechanisms on EACCES
1318  * but will return the EACCES to the caller. Note that the VFS does not call
1319  * unlink on negative dentries currently.
1320  */
1321 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1322 {
1323         int rc = 0;
1324         unsigned int xid;
1325         char *full_path = NULL;
1326         struct inode *inode = d_inode(dentry);
1327         struct cifsInodeInfo *cifs_inode;
1328         struct super_block *sb = dir->i_sb;
1329         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1330         struct tcon_link *tlink;
1331         struct cifs_tcon *tcon;
1332         struct TCP_Server_Info *server;
1333         struct iattr *attrs = NULL;
1334         __u32 dosattr = 0, origattr = 0;
1335
1336         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1337
1338         tlink = cifs_sb_tlink(cifs_sb);
1339         if (IS_ERR(tlink))
1340                 return PTR_ERR(tlink);
1341         tcon = tlink_tcon(tlink);
1342         server = tcon->ses->server;
1343
1344         xid = get_xid();
1345
1346         /* Unlink can be called from rename so we can not take the
1347          * sb->s_vfs_rename_mutex here */
1348         full_path = build_path_from_dentry(dentry);
1349         if (full_path == NULL) {
1350                 rc = -ENOMEM;
1351                 goto unlink_out;
1352         }
1353
1354         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1355                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1356                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1357                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1358                         cifs_remap(cifs_sb));
1359                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1360                 if ((rc == 0) || (rc == -ENOENT))
1361                         goto psx_del_no_retry;
1362         }
1363
1364 retry_std_delete:
1365         if (!server->ops->unlink) {
1366                 rc = -ENOSYS;
1367                 goto psx_del_no_retry;
1368         }
1369
1370         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1371
1372 psx_del_no_retry:
1373         if (!rc) {
1374                 if (inode)
1375                         cifs_drop_nlink(inode);
1376         } else if (rc == -ENOENT) {
1377                 d_drop(dentry);
1378         } else if (rc == -EBUSY) {
1379                 if (server->ops->rename_pending_delete) {
1380                         rc = server->ops->rename_pending_delete(full_path,
1381                                                                 dentry, xid);
1382                         if (rc == 0)
1383                                 cifs_drop_nlink(inode);
1384                 }
1385         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1386                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1387                 if (attrs == NULL) {
1388                         rc = -ENOMEM;
1389                         goto out_reval;
1390                 }
1391
1392                 /* try to reset dos attributes */
1393                 cifs_inode = CIFS_I(inode);
1394                 origattr = cifs_inode->cifsAttrs;
1395                 if (origattr == 0)
1396                         origattr |= ATTR_NORMAL;
1397                 dosattr = origattr & ~ATTR_READONLY;
1398                 if (dosattr == 0)
1399                         dosattr |= ATTR_NORMAL;
1400                 dosattr |= ATTR_HIDDEN;
1401
1402                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1403                 if (rc != 0)
1404                         goto out_reval;
1405
1406                 goto retry_std_delete;
1407         }
1408
1409         /* undo the setattr if we errored out and it's needed */
1410         if (rc != 0 && dosattr != 0)
1411                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1412
1413 out_reval:
1414         if (inode) {
1415                 cifs_inode = CIFS_I(inode);
1416                 cifs_inode->time = 0;   /* will force revalidate to get info
1417                                            when needed */
1418                 inode->i_ctime = current_time(inode);
1419         }
1420         dir->i_ctime = dir->i_mtime = current_time(dir);
1421         cifs_inode = CIFS_I(dir);
1422         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1423 unlink_out:
1424         kfree(full_path);
1425         kfree(attrs);
1426         free_xid(xid);
1427         cifs_put_tlink(tlink);
1428         return rc;
1429 }
1430
1431 static int
1432 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1433                  const char *full_path, struct cifs_sb_info *cifs_sb,
1434                  struct cifs_tcon *tcon, const unsigned int xid)
1435 {
1436         int rc = 0;
1437         struct inode *inode = NULL;
1438
1439         if (tcon->unix_ext)
1440                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1441                                               xid);
1442         else
1443                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1444                                          xid, NULL);
1445
1446         if (rc)
1447                 return rc;
1448
1449         /*
1450          * setting nlink not necessary except in cases where we failed to get it
1451          * from the server or was set bogus. Also, since this is a brand new
1452          * inode, no need to grab the i_lock before setting the i_nlink.
1453          */
1454         if (inode->i_nlink < 2)
1455                 set_nlink(inode, 2);
1456         mode &= ~current_umask();
1457         /* must turn on setgid bit if parent dir has it */
1458         if (parent->i_mode & S_ISGID)
1459                 mode |= S_ISGID;
1460
1461         if (tcon->unix_ext) {
1462                 struct cifs_unix_set_info_args args = {
1463                         .mode   = mode,
1464                         .ctime  = NO_CHANGE_64,
1465                         .atime  = NO_CHANGE_64,
1466                         .mtime  = NO_CHANGE_64,
1467                         .device = 0,
1468                 };
1469                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1470                         args.uid = current_fsuid();
1471                         if (parent->i_mode & S_ISGID)
1472                                 args.gid = parent->i_gid;
1473                         else
1474                                 args.gid = current_fsgid();
1475                 } else {
1476                         args.uid = INVALID_UID; /* no change */
1477                         args.gid = INVALID_GID; /* no change */
1478                 }
1479                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1480                                        cifs_sb->local_nls,
1481                                        cifs_remap(cifs_sb));
1482         } else {
1483                 struct TCP_Server_Info *server = tcon->ses->server;
1484                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1485                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1486                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1487                                                    tcon, xid);
1488                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1489                         inode->i_mode = (mode | S_IFDIR);
1490
1491                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1492                         inode->i_uid = current_fsuid();
1493                         if (inode->i_mode & S_ISGID)
1494                                 inode->i_gid = parent->i_gid;
1495                         else
1496                                 inode->i_gid = current_fsgid();
1497                 }
1498         }
1499         d_instantiate(dentry, inode);
1500         return rc;
1501 }
1502
1503 static int
1504 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1505                  const char *full_path, struct cifs_sb_info *cifs_sb,
1506                  struct cifs_tcon *tcon, const unsigned int xid)
1507 {
1508         int rc = 0;
1509         u32 oplock = 0;
1510         FILE_UNIX_BASIC_INFO *info = NULL;
1511         struct inode *newinode = NULL;
1512         struct cifs_fattr fattr;
1513
1514         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1515         if (info == NULL) {
1516                 rc = -ENOMEM;
1517                 goto posix_mkdir_out;
1518         }
1519
1520         mode &= ~current_umask();
1521         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1522                              NULL /* netfid */, info, &oplock, full_path,
1523                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1524         if (rc == -EOPNOTSUPP)
1525                 goto posix_mkdir_out;
1526         else if (rc) {
1527                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1528                 d_drop(dentry);
1529                 goto posix_mkdir_out;
1530         }
1531
1532         if (info->Type == cpu_to_le32(-1))
1533                 /* no return info, go query for it */
1534                 goto posix_mkdir_get_info;
1535         /*
1536          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1537          * need to set uid/gid.
1538          */
1539
1540         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1541         cifs_fill_uniqueid(inode->i_sb, &fattr);
1542         newinode = cifs_iget(inode->i_sb, &fattr);
1543         if (!newinode)
1544                 goto posix_mkdir_get_info;
1545
1546         d_instantiate(dentry, newinode);
1547
1548 #ifdef CONFIG_CIFS_DEBUG2
1549         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1550                  dentry, dentry, newinode);
1551
1552         if (newinode->i_nlink != 2)
1553                 cifs_dbg(FYI, "unexpected number of links %d\n",
1554                          newinode->i_nlink);
1555 #endif
1556
1557 posix_mkdir_out:
1558         kfree(info);
1559         return rc;
1560 posix_mkdir_get_info:
1561         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1562                               xid);
1563         goto posix_mkdir_out;
1564 }
1565
1566 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1567 {
1568         int rc = 0;
1569         unsigned int xid;
1570         struct cifs_sb_info *cifs_sb;
1571         struct tcon_link *tlink;
1572         struct cifs_tcon *tcon;
1573         struct TCP_Server_Info *server;
1574         char *full_path;
1575
1576         cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1577                  mode, inode);
1578
1579         cifs_sb = CIFS_SB(inode->i_sb);
1580         tlink = cifs_sb_tlink(cifs_sb);
1581         if (IS_ERR(tlink))
1582                 return PTR_ERR(tlink);
1583         tcon = tlink_tcon(tlink);
1584
1585         xid = get_xid();
1586
1587         full_path = build_path_from_dentry(direntry);
1588         if (full_path == NULL) {
1589                 rc = -ENOMEM;
1590                 goto mkdir_out;
1591         }
1592
1593         server = tcon->ses->server;
1594
1595         if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1596                 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1597                                               cifs_sb);
1598                 d_drop(direntry); /* for time being always refresh inode info */
1599                 goto mkdir_out;
1600         }
1601
1602         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1603                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1604                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1605                                       tcon, xid);
1606                 if (rc != -EOPNOTSUPP)
1607                         goto mkdir_out;
1608         }
1609
1610         if (!server->ops->mkdir) {
1611                 rc = -ENOSYS;
1612                 goto mkdir_out;
1613         }
1614
1615         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1616         rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1617         if (rc) {
1618                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1619                 d_drop(direntry);
1620                 goto mkdir_out;
1621         }
1622
1623         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1624                               xid);
1625 mkdir_out:
1626         /*
1627          * Force revalidate to get parent dir info when needed since cached
1628          * attributes are invalid now.
1629          */
1630         CIFS_I(inode)->time = 0;
1631         kfree(full_path);
1632         free_xid(xid);
1633         cifs_put_tlink(tlink);
1634         return rc;
1635 }
1636
1637 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1638 {
1639         int rc = 0;
1640         unsigned int xid;
1641         struct cifs_sb_info *cifs_sb;
1642         struct tcon_link *tlink;
1643         struct cifs_tcon *tcon;
1644         struct TCP_Server_Info *server;
1645         char *full_path = NULL;
1646         struct cifsInodeInfo *cifsInode;
1647
1648         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1649
1650         xid = get_xid();
1651
1652         full_path = build_path_from_dentry(direntry);
1653         if (full_path == NULL) {
1654                 rc = -ENOMEM;
1655                 goto rmdir_exit;
1656         }
1657
1658         cifs_sb = CIFS_SB(inode->i_sb);
1659         tlink = cifs_sb_tlink(cifs_sb);
1660         if (IS_ERR(tlink)) {
1661                 rc = PTR_ERR(tlink);
1662                 goto rmdir_exit;
1663         }
1664         tcon = tlink_tcon(tlink);
1665         server = tcon->ses->server;
1666
1667         if (!server->ops->rmdir) {
1668                 rc = -ENOSYS;
1669                 cifs_put_tlink(tlink);
1670                 goto rmdir_exit;
1671         }
1672
1673         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1674         cifs_put_tlink(tlink);
1675
1676         if (!rc) {
1677                 spin_lock(&d_inode(direntry)->i_lock);
1678                 i_size_write(d_inode(direntry), 0);
1679                 clear_nlink(d_inode(direntry));
1680                 spin_unlock(&d_inode(direntry)->i_lock);
1681         }
1682
1683         cifsInode = CIFS_I(d_inode(direntry));
1684         /* force revalidate to go get info when needed */
1685         cifsInode->time = 0;
1686
1687         cifsInode = CIFS_I(inode);
1688         /*
1689          * Force revalidate to get parent dir info when needed since cached
1690          * attributes are invalid now.
1691          */
1692         cifsInode->time = 0;
1693
1694         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1695                 current_time(inode);
1696
1697 rmdir_exit:
1698         kfree(full_path);
1699         free_xid(xid);
1700         return rc;
1701 }
1702
1703 static int
1704 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1705                const char *from_path, struct dentry *to_dentry,
1706                const char *to_path)
1707 {
1708         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1709         struct tcon_link *tlink;
1710         struct cifs_tcon *tcon;
1711         struct TCP_Server_Info *server;
1712         struct cifs_fid fid;
1713         struct cifs_open_parms oparms;
1714         int oplock, rc;
1715
1716         tlink = cifs_sb_tlink(cifs_sb);
1717         if (IS_ERR(tlink))
1718                 return PTR_ERR(tlink);
1719         tcon = tlink_tcon(tlink);
1720         server = tcon->ses->server;
1721
1722         if (!server->ops->rename)
1723                 return -ENOSYS;
1724
1725         /* try path-based rename first */
1726         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1727
1728         /*
1729          * Don't bother with rename by filehandle unless file is busy and
1730          * source. Note that cross directory moves do not work with
1731          * rename by filehandle to various Windows servers.
1732          */
1733         if (rc == 0 || rc != -EBUSY)
1734                 goto do_rename_exit;
1735
1736         /* Don't fall back to using SMB on SMB 2+ mount */
1737         if (server->vals->protocol_id != 0)
1738                 goto do_rename_exit;
1739
1740         /* open-file renames don't work across directories */
1741         if (to_dentry->d_parent != from_dentry->d_parent)
1742                 goto do_rename_exit;
1743
1744         oparms.tcon = tcon;
1745         oparms.cifs_sb = cifs_sb;
1746         /* open the file to be renamed -- we need DELETE perms */
1747         oparms.desired_access = DELETE;
1748         oparms.create_options = CREATE_NOT_DIR;
1749         oparms.disposition = FILE_OPEN;
1750         oparms.path = from_path;
1751         oparms.fid = &fid;
1752         oparms.reconnect = false;
1753
1754         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1755         if (rc == 0) {
1756                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1757                                 (const char *) to_dentry->d_name.name,
1758                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1759                 CIFSSMBClose(xid, tcon, fid.netfid);
1760         }
1761 do_rename_exit:
1762         cifs_put_tlink(tlink);
1763         return rc;
1764 }
1765
1766 int
1767 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1768              struct inode *target_dir, struct dentry *target_dentry,
1769              unsigned int flags)
1770 {
1771         char *from_name = NULL;
1772         char *to_name = NULL;
1773         struct cifs_sb_info *cifs_sb;
1774         struct tcon_link *tlink;
1775         struct cifs_tcon *tcon;
1776         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1777         FILE_UNIX_BASIC_INFO *info_buf_target;
1778         unsigned int xid;
1779         int rc, tmprc;
1780
1781         if (flags & ~RENAME_NOREPLACE)
1782                 return -EINVAL;
1783
1784         cifs_sb = CIFS_SB(source_dir->i_sb);
1785         tlink = cifs_sb_tlink(cifs_sb);
1786         if (IS_ERR(tlink))
1787                 return PTR_ERR(tlink);
1788         tcon = tlink_tcon(tlink);
1789
1790         xid = get_xid();
1791
1792         /*
1793          * we already have the rename sem so we do not need to
1794          * grab it again here to protect the path integrity
1795          */
1796         from_name = build_path_from_dentry(source_dentry);
1797         if (from_name == NULL) {
1798                 rc = -ENOMEM;
1799                 goto cifs_rename_exit;
1800         }
1801
1802         to_name = build_path_from_dentry(target_dentry);
1803         if (to_name == NULL) {
1804                 rc = -ENOMEM;
1805                 goto cifs_rename_exit;
1806         }
1807
1808         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1809                             to_name);
1810
1811         /*
1812          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1813          */
1814         if (flags & RENAME_NOREPLACE)
1815                 goto cifs_rename_exit;
1816
1817         if (rc == -EEXIST && tcon->unix_ext) {
1818                 /*
1819                  * Are src and dst hardlinks of same inode? We can only tell
1820                  * with unix extensions enabled.
1821                  */
1822                 info_buf_source =
1823                         kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1824                                         GFP_KERNEL);
1825                 if (info_buf_source == NULL) {
1826                         rc = -ENOMEM;
1827                         goto cifs_rename_exit;
1828                 }
1829
1830                 info_buf_target = info_buf_source + 1;
1831                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1832                                              info_buf_source,
1833                                              cifs_sb->local_nls,
1834                                              cifs_remap(cifs_sb));
1835                 if (tmprc != 0)
1836                         goto unlink_target;
1837
1838                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1839                                              info_buf_target,
1840                                              cifs_sb->local_nls,
1841                                              cifs_remap(cifs_sb));
1842
1843                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1844                                    info_buf_target->UniqueId)) {
1845                         /* same file, POSIX says that this is a noop */
1846                         rc = 0;
1847                         goto cifs_rename_exit;
1848                 }
1849         }
1850         /*
1851          * else ... BB we could add the same check for Windows by
1852          * checking the UniqueId via FILE_INTERNAL_INFO
1853          */
1854
1855 unlink_target:
1856         /* Try unlinking the target dentry if it's not negative */
1857         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1858                 if (d_is_dir(target_dentry))
1859                         tmprc = cifs_rmdir(target_dir, target_dentry);
1860                 else
1861                         tmprc = cifs_unlink(target_dir, target_dentry);
1862                 if (tmprc)
1863                         goto cifs_rename_exit;
1864                 rc = cifs_do_rename(xid, source_dentry, from_name,
1865                                     target_dentry, to_name);
1866         }
1867
1868         /* force revalidate to go get info when needed */
1869         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1870
1871         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1872                 target_dir->i_mtime = current_time(source_dir);
1873
1874 cifs_rename_exit:
1875         kfree(info_buf_source);
1876         kfree(from_name);
1877         kfree(to_name);
1878         free_xid(xid);
1879         cifs_put_tlink(tlink);
1880         return rc;
1881 }
1882
1883 static bool
1884 cifs_inode_needs_reval(struct inode *inode)
1885 {
1886         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1887         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1888
1889         if (cifs_i->time == 0)
1890                 return true;
1891
1892         if (CIFS_CACHE_READ(cifs_i))
1893                 return false;
1894
1895         if (!lookupCacheEnabled)
1896                 return true;
1897
1898         if (!cifs_sb->actimeo)
1899                 return true;
1900
1901         if (!time_in_range(jiffies, cifs_i->time,
1902                                 cifs_i->time + cifs_sb->actimeo))
1903                 return true;
1904
1905         /* hardlinked files w/ noserverino get "special" treatment */
1906         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1907             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1908                 return true;
1909
1910         return false;
1911 }
1912
1913 /*
1914  * Zap the cache. Called when invalid_mapping flag is set.
1915  */
1916 int
1917 cifs_invalidate_mapping(struct inode *inode)
1918 {
1919         int rc = 0;
1920
1921         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1922                 rc = invalidate_inode_pages2(inode->i_mapping);
1923                 if (rc)
1924                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1925                                  __func__, inode);
1926         }
1927
1928         cifs_fscache_reset_inode_cookie(inode);
1929         return rc;
1930 }
1931
1932 /**
1933  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1934  * @word: long word containing the bit lock
1935  */
1936 static int
1937 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1938 {
1939         freezable_schedule_unsafe();
1940         if (signal_pending_state(mode, current))
1941                 return -ERESTARTSYS;
1942         return 0;
1943 }
1944
1945 int
1946 cifs_revalidate_mapping(struct inode *inode)
1947 {
1948         int rc;
1949         unsigned long *flags = &CIFS_I(inode)->flags;
1950
1951         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1952                                      TASK_KILLABLE);
1953         if (rc)
1954                 return rc;
1955
1956         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1957                 rc = cifs_invalidate_mapping(inode);
1958                 if (rc)
1959                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1960         }
1961
1962         clear_bit_unlock(CIFS_INO_LOCK, flags);
1963         smp_mb__after_atomic();
1964         wake_up_bit(flags, CIFS_INO_LOCK);
1965
1966         return rc;
1967 }
1968
1969 int
1970 cifs_zap_mapping(struct inode *inode)
1971 {
1972         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1973         return cifs_revalidate_mapping(inode);
1974 }
1975
1976 int cifs_revalidate_file_attr(struct file *filp)
1977 {
1978         int rc = 0;
1979         struct inode *inode = file_inode(filp);
1980         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1981
1982         if (!cifs_inode_needs_reval(inode))
1983                 return rc;
1984
1985         if (tlink_tcon(cfile->tlink)->unix_ext)
1986                 rc = cifs_get_file_info_unix(filp);
1987         else
1988                 rc = cifs_get_file_info(filp);
1989
1990         return rc;
1991 }
1992
1993 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1994 {
1995         unsigned int xid;
1996         int rc = 0;
1997         struct inode *inode = d_inode(dentry);
1998         struct super_block *sb = dentry->d_sb;
1999         char *full_path = NULL;
2000
2001         if (inode == NULL)
2002                 return -ENOENT;
2003
2004         if (!cifs_inode_needs_reval(inode))
2005                 return rc;
2006
2007         xid = get_xid();
2008
2009         /* can not safely grab the rename sem here if rename calls revalidate
2010            since that would deadlock */
2011         full_path = build_path_from_dentry(dentry);
2012         if (full_path == NULL) {
2013                 rc = -ENOMEM;
2014                 goto out;
2015         }
2016
2017         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2018                  full_path, inode, inode->i_count.counter,
2019                  dentry, cifs_get_time(dentry), jiffies);
2020
2021         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2022                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2023         else
2024                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2025                                          xid, NULL);
2026
2027 out:
2028         kfree(full_path);
2029         free_xid(xid);
2030         return rc;
2031 }
2032
2033 int cifs_revalidate_file(struct file *filp)
2034 {
2035         int rc;
2036         struct inode *inode = file_inode(filp);
2037
2038         rc = cifs_revalidate_file_attr(filp);
2039         if (rc)
2040                 return rc;
2041
2042         return cifs_revalidate_mapping(inode);
2043 }
2044
2045 /* revalidate a dentry's inode attributes */
2046 int cifs_revalidate_dentry(struct dentry *dentry)
2047 {
2048         int rc;
2049         struct inode *inode = d_inode(dentry);
2050
2051         rc = cifs_revalidate_dentry_attr(dentry);
2052         if (rc)
2053                 return rc;
2054
2055         return cifs_revalidate_mapping(inode);
2056 }
2057
2058 int cifs_getattr(const struct path *path, struct kstat *stat,
2059                  u32 request_mask, unsigned int flags)
2060 {
2061         struct dentry *dentry = path->dentry;
2062         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2063         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2064         struct inode *inode = d_inode(dentry);
2065         int rc;
2066
2067         /*
2068          * We need to be sure that all dirty pages are written and the server
2069          * has actual ctime, mtime and file length.
2070          */
2071         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2072             inode->i_mapping->nrpages != 0) {
2073                 rc = filemap_fdatawait(inode->i_mapping);
2074                 if (rc) {
2075                         mapping_set_error(inode->i_mapping, rc);
2076                         return rc;
2077                 }
2078         }
2079
2080         rc = cifs_revalidate_dentry_attr(dentry);
2081         if (rc)
2082                 return rc;
2083
2084         generic_fillattr(inode, stat);
2085         stat->blksize = cifs_sb->bsize;
2086         stat->ino = CIFS_I(inode)->uniqueid;
2087
2088         /* old CIFS Unix Extensions doesn't return create time */
2089         if (CIFS_I(inode)->createtime) {
2090                 stat->result_mask |= STATX_BTIME;
2091                 stat->btime =
2092                       cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2093         }
2094
2095         stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2096         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2097                 stat->attributes |= STATX_ATTR_COMPRESSED;
2098         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2099                 stat->attributes |= STATX_ATTR_ENCRYPTED;
2100
2101         /*
2102          * If on a multiuser mount without unix extensions or cifsacl being
2103          * enabled, and the admin hasn't overridden them, set the ownership
2104          * to the fsuid/fsgid of the current process.
2105          */
2106         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2107             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2108             !tcon->unix_ext) {
2109                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2110                         stat->uid = current_fsuid();
2111                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2112                         stat->gid = current_fsgid();
2113         }
2114         return rc;
2115 }
2116
2117 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2118                 u64 len)
2119 {
2120         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2121         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2122         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2123         struct TCP_Server_Info *server = tcon->ses->server;
2124         struct cifsFileInfo *cfile;
2125         int rc;
2126
2127         /*
2128          * We need to be sure that all dirty pages are written as they
2129          * might fill holes on the server.
2130          */
2131         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2132             inode->i_mapping->nrpages != 0) {
2133                 rc = filemap_fdatawait(inode->i_mapping);
2134                 if (rc) {
2135                         mapping_set_error(inode->i_mapping, rc);
2136                         return rc;
2137                 }
2138         }
2139
2140         cfile = find_readable_file(cifs_i, false);
2141         if (cfile == NULL)
2142                 return -EINVAL;
2143
2144         if (server->ops->fiemap) {
2145                 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2146                 cifsFileInfo_put(cfile);
2147                 return rc;
2148         }
2149
2150         cifsFileInfo_put(cfile);
2151         return -ENOTSUPP;
2152 }
2153
2154 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2155 {
2156         pgoff_t index = from >> PAGE_SHIFT;
2157         unsigned offset = from & (PAGE_SIZE - 1);
2158         struct page *page;
2159         int rc = 0;
2160
2161         page = grab_cache_page(mapping, index);
2162         if (!page)
2163                 return -ENOMEM;
2164
2165         zero_user_segment(page, offset, PAGE_SIZE);
2166         unlock_page(page);
2167         put_page(page);
2168         return rc;
2169 }
2170
2171 static void cifs_setsize(struct inode *inode, loff_t offset)
2172 {
2173         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2174
2175         spin_lock(&inode->i_lock);
2176         i_size_write(inode, offset);
2177         spin_unlock(&inode->i_lock);
2178
2179         /* Cached inode must be refreshed on truncate */
2180         cifs_i->time = 0;
2181         truncate_pagecache(inode, offset);
2182 }
2183
2184 static int
2185 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2186                    unsigned int xid, char *full_path)
2187 {
2188         int rc;
2189         struct cifsFileInfo *open_file;
2190         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2191         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2192         struct tcon_link *tlink = NULL;
2193         struct cifs_tcon *tcon = NULL;
2194         struct TCP_Server_Info *server;
2195
2196         /*
2197          * To avoid spurious oplock breaks from server, in the case of
2198          * inodes that we already have open, avoid doing path based
2199          * setting of file size if we can do it by handle.
2200          * This keeps our caching token (oplock) and avoids timeouts
2201          * when the local oplock break takes longer to flush
2202          * writebehind data than the SMB timeout for the SetPathInfo
2203          * request would allow
2204          */
2205         open_file = find_writable_file(cifsInode, true);
2206         if (open_file) {
2207                 tcon = tlink_tcon(open_file->tlink);
2208                 server = tcon->ses->server;
2209                 if (server->ops->set_file_size)
2210                         rc = server->ops->set_file_size(xid, tcon, open_file,
2211                                                         attrs->ia_size, false);
2212                 else
2213                         rc = -ENOSYS;
2214                 cifsFileInfo_put(open_file);
2215                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2216         } else
2217                 rc = -EINVAL;
2218
2219         if (!rc)
2220                 goto set_size_out;
2221
2222         if (tcon == NULL) {
2223                 tlink = cifs_sb_tlink(cifs_sb);
2224                 if (IS_ERR(tlink))
2225                         return PTR_ERR(tlink);
2226                 tcon = tlink_tcon(tlink);
2227                 server = tcon->ses->server;
2228         }
2229
2230         /*
2231          * Set file size by pathname rather than by handle either because no
2232          * valid, writeable file handle for it was found or because there was
2233          * an error setting it by handle.
2234          */
2235         if (server->ops->set_path_size)
2236                 rc = server->ops->set_path_size(xid, tcon, full_path,
2237                                                 attrs->ia_size, cifs_sb, false);
2238         else
2239                 rc = -ENOSYS;
2240         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2241
2242         if (tlink)
2243                 cifs_put_tlink(tlink);
2244
2245 set_size_out:
2246         if (rc == 0) {
2247                 cifsInode->server_eof = attrs->ia_size;
2248                 cifs_setsize(inode, attrs->ia_size);
2249                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2250         }
2251
2252         return rc;
2253 }
2254
2255 static int
2256 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2257 {
2258         int rc;
2259         unsigned int xid;
2260         char *full_path = NULL;
2261         struct inode *inode = d_inode(direntry);
2262         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2263         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2264         struct tcon_link *tlink;
2265         struct cifs_tcon *pTcon;
2266         struct cifs_unix_set_info_args *args = NULL;
2267         struct cifsFileInfo *open_file;
2268
2269         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2270                  direntry, attrs->ia_valid);
2271
2272         xid = get_xid();
2273
2274         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2275                 attrs->ia_valid |= ATTR_FORCE;
2276
2277         rc = setattr_prepare(direntry, attrs);
2278         if (rc < 0)
2279                 goto out;
2280
2281         full_path = build_path_from_dentry(direntry);
2282         if (full_path == NULL) {
2283                 rc = -ENOMEM;
2284                 goto out;
2285         }
2286
2287         /*
2288          * Attempt to flush data before changing attributes. We need to do
2289          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2290          * ownership or mode then we may also need to do this. Here, we take
2291          * the safe way out and just do the flush on all setattr requests. If
2292          * the flush returns error, store it to report later and continue.
2293          *
2294          * BB: This should be smarter. Why bother flushing pages that
2295          * will be truncated anyway? Also, should we error out here if
2296          * the flush returns error?
2297          */
2298         rc = filemap_write_and_wait(inode->i_mapping);
2299         if (is_interrupt_error(rc)) {
2300                 rc = -ERESTARTSYS;
2301                 goto out;
2302         }
2303
2304         mapping_set_error(inode->i_mapping, rc);
2305         rc = 0;
2306
2307         if (attrs->ia_valid & ATTR_SIZE) {
2308                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2309                 if (rc != 0)
2310                         goto out;
2311         }
2312
2313         /* skip mode change if it's just for clearing setuid/setgid */
2314         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2315                 attrs->ia_valid &= ~ATTR_MODE;
2316
2317         args = kmalloc(sizeof(*args), GFP_KERNEL);
2318         if (args == NULL) {
2319                 rc = -ENOMEM;
2320                 goto out;
2321         }
2322
2323         /* set up the struct */
2324         if (attrs->ia_valid & ATTR_MODE)
2325                 args->mode = attrs->ia_mode;
2326         else
2327                 args->mode = NO_CHANGE_64;
2328
2329         if (attrs->ia_valid & ATTR_UID)
2330                 args->uid = attrs->ia_uid;
2331         else
2332                 args->uid = INVALID_UID; /* no change */
2333
2334         if (attrs->ia_valid & ATTR_GID)
2335                 args->gid = attrs->ia_gid;
2336         else
2337                 args->gid = INVALID_GID; /* no change */
2338
2339         if (attrs->ia_valid & ATTR_ATIME)
2340                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2341         else
2342                 args->atime = NO_CHANGE_64;
2343
2344         if (attrs->ia_valid & ATTR_MTIME)
2345                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2346         else
2347                 args->mtime = NO_CHANGE_64;
2348
2349         if (attrs->ia_valid & ATTR_CTIME)
2350                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2351         else
2352                 args->ctime = NO_CHANGE_64;
2353
2354         args->device = 0;
2355         open_file = find_writable_file(cifsInode, true);
2356         if (open_file) {
2357                 u16 nfid = open_file->fid.netfid;
2358                 u32 npid = open_file->pid;
2359                 pTcon = tlink_tcon(open_file->tlink);
2360                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2361                 cifsFileInfo_put(open_file);
2362         } else {
2363                 tlink = cifs_sb_tlink(cifs_sb);
2364                 if (IS_ERR(tlink)) {
2365                         rc = PTR_ERR(tlink);
2366                         goto out;
2367                 }
2368                 pTcon = tlink_tcon(tlink);
2369                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2370                                     cifs_sb->local_nls,
2371                                     cifs_remap(cifs_sb));
2372                 cifs_put_tlink(tlink);
2373         }
2374
2375         if (rc)
2376                 goto out;
2377
2378         if ((attrs->ia_valid & ATTR_SIZE) &&
2379             attrs->ia_size != i_size_read(inode))
2380                 truncate_setsize(inode, attrs->ia_size);
2381
2382         setattr_copy(inode, attrs);
2383         mark_inode_dirty(inode);
2384
2385         /* force revalidate when any of these times are set since some
2386            of the fs types (eg ext3, fat) do not have fine enough
2387            time granularity to match protocol, and we do not have a
2388            a way (yet) to query the server fs's time granularity (and
2389            whether it rounds times down).
2390         */
2391         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2392                 cifsInode->time = 0;
2393 out:
2394         kfree(args);
2395         kfree(full_path);
2396         free_xid(xid);
2397         return rc;
2398 }
2399
2400 static int
2401 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2402 {
2403         unsigned int xid;
2404         kuid_t uid = INVALID_UID;
2405         kgid_t gid = INVALID_GID;
2406         struct inode *inode = d_inode(direntry);
2407         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2408         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2409         struct cifsFileInfo *wfile;
2410         struct cifs_tcon *tcon;
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->ia_valid 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_MTIME) {
2458                 rc = cifs_get_writable_file(cifsInode, false, &wfile);
2459                 if (!rc) {
2460                         tcon = tlink_tcon(wfile->tlink);
2461                         rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2462                         cifsFileInfo_put(wfile);
2463                         if (rc)
2464                                 return rc;
2465                 } else if (rc != -EBADF)
2466                         return rc;
2467                 else
2468                         rc = 0;
2469         }
2470
2471         if (attrs->ia_valid & ATTR_SIZE) {
2472                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2473                 if (rc != 0)
2474                         goto cifs_setattr_exit;
2475         }
2476
2477         if (attrs->ia_valid & ATTR_UID)
2478                 uid = attrs->ia_uid;
2479
2480         if (attrs->ia_valid & ATTR_GID)
2481                 gid = attrs->ia_gid;
2482
2483         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2484                 if (uid_valid(uid) || gid_valid(gid)) {
2485                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2486                                                         uid, gid);
2487                         if (rc) {
2488                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2489                                          __func__, rc);
2490                                 goto cifs_setattr_exit;
2491                         }
2492                 }
2493         } else
2494         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2495                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2496
2497         /* skip mode change if it's just for clearing setuid/setgid */
2498         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2499                 attrs->ia_valid &= ~ATTR_MODE;
2500
2501         if (attrs->ia_valid & ATTR_MODE) {
2502                 mode = attrs->ia_mode;
2503                 rc = 0;
2504                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2505                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2506                                                 INVALID_UID, INVALID_GID);
2507                         if (rc) {
2508                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2509                                          __func__, rc);
2510                                 goto cifs_setattr_exit;
2511                         }
2512                 } else
2513                 if (((mode & S_IWUGO) == 0) &&
2514                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2515
2516                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2517
2518                         /* fix up mode if we're not using dynperm */
2519                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2520                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2521                 } else if ((mode & S_IWUGO) &&
2522                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2523
2524                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2525                         /* Attributes of 0 are ignored */
2526                         if (dosattr == 0)
2527                                 dosattr |= ATTR_NORMAL;
2528
2529                         /* reset local inode permissions to normal */
2530                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2531                                 attrs->ia_mode &= ~(S_IALLUGO);
2532                                 if (S_ISDIR(inode->i_mode))
2533                                         attrs->ia_mode |=
2534                                                 cifs_sb->mnt_dir_mode;
2535                                 else
2536                                         attrs->ia_mode |=
2537                                                 cifs_sb->mnt_file_mode;
2538                         }
2539                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2540                         /* ignore mode change - ATTR_READONLY hasn't changed */
2541                         attrs->ia_valid &= ~ATTR_MODE;
2542                 }
2543         }
2544
2545         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2546             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2547                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2548                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2549
2550                 /* Even if error on time set, no sense failing the call if
2551                 the server would set the time to a reasonable value anyway,
2552                 and this check ensures that we are not being called from
2553                 sys_utimes in which case we ought to fail the call back to
2554                 the user when the server rejects the call */
2555                 if ((rc) && (attrs->ia_valid &
2556                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2557                         rc = 0;
2558         }
2559
2560         /* do not need local check to inode_check_ok since the server does
2561            that */
2562         if (rc)
2563                 goto cifs_setattr_exit;
2564
2565         if ((attrs->ia_valid & ATTR_SIZE) &&
2566             attrs->ia_size != i_size_read(inode))
2567                 truncate_setsize(inode, attrs->ia_size);
2568
2569         setattr_copy(inode, attrs);
2570         mark_inode_dirty(inode);
2571
2572 cifs_setattr_exit:
2573         kfree(full_path);
2574         free_xid(xid);
2575         return rc;
2576 }
2577
2578 int
2579 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2580 {
2581         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2582         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2583
2584         if (pTcon->unix_ext)
2585                 return cifs_setattr_unix(direntry, attrs);
2586
2587         return cifs_setattr_nounix(direntry, attrs);
2588
2589         /* BB: add cifs_setattr_legacy for really old servers */
2590 }
2591
2592 #if 0
2593 void cifs_delete_inode(struct inode *inode)
2594 {
2595         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2596         /* may have to add back in if and when safe distributed caching of
2597            directories added e.g. via FindNotify */
2598 }
2599 #endif