fs/cifs/inode.c

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