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, 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         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1633                               xid);
1634 mkdir_out:
1635         /*
1636          * Force revalidate to get parent dir info when needed since cached
1637          * attributes are invalid now.
1638          */
1639         CIFS_I(inode)->time = 0;
1640         kfree(full_path);
1641         free_xid(xid);
1642         cifs_put_tlink(tlink);
1643         return rc;
1644 }
1645
1646 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1647 {
1648         int rc = 0;
1649         unsigned int xid;
1650         struct cifs_sb_info *cifs_sb;
1651         struct tcon_link *tlink;
1652         struct cifs_tcon *tcon;
1653         struct TCP_Server_Info *server;
1654         char *full_path = NULL;
1655         struct cifsInodeInfo *cifsInode;
1656
1657         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1658
1659         xid = get_xid();
1660
1661         full_path = build_path_from_dentry(direntry);
1662         if (full_path == NULL) {
1663                 rc = -ENOMEM;
1664                 goto rmdir_exit;
1665         }
1666
1667         cifs_sb = CIFS_SB(inode->i_sb);
1668         tlink = cifs_sb_tlink(cifs_sb);
1669         if (IS_ERR(tlink)) {
1670                 rc = PTR_ERR(tlink);
1671                 goto rmdir_exit;
1672         }
1673         tcon = tlink_tcon(tlink);
1674         server = tcon->ses->server;
1675
1676         if (!server->ops->rmdir) {
1677                 rc = -ENOSYS;
1678                 cifs_put_tlink(tlink);
1679                 goto rmdir_exit;
1680         }
1681
1682         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1683         cifs_put_tlink(tlink);
1684
1685         if (!rc) {
1686                 spin_lock(&d_inode(direntry)->i_lock);
1687                 i_size_write(d_inode(direntry), 0);
1688                 clear_nlink(d_inode(direntry));
1689                 spin_unlock(&d_inode(direntry)->i_lock);
1690         }
1691
1692         cifsInode = CIFS_I(d_inode(direntry));
1693         /* force revalidate to go get info when needed */
1694         cifsInode->time = 0;
1695
1696         cifsInode = CIFS_I(inode);
1697         /*
1698          * Force revalidate to get parent dir info when needed since cached
1699          * attributes are invalid now.
1700          */
1701         cifsInode->time = 0;
1702
1703         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1704                 current_time(inode);
1705
1706 rmdir_exit:
1707         kfree(full_path);
1708         free_xid(xid);
1709         return rc;
1710 }
1711
1712 static int
1713 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1714                const char *from_path, struct dentry *to_dentry,
1715                const char *to_path)
1716 {
1717         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1718         struct tcon_link *tlink;
1719         struct cifs_tcon *tcon;
1720         struct TCP_Server_Info *server;
1721         struct cifs_fid fid;
1722         struct cifs_open_parms oparms;
1723         int oplock, rc;
1724
1725         tlink = cifs_sb_tlink(cifs_sb);
1726         if (IS_ERR(tlink))
1727                 return PTR_ERR(tlink);
1728         tcon = tlink_tcon(tlink);
1729         server = tcon->ses->server;
1730
1731         if (!server->ops->rename)
1732                 return -ENOSYS;
1733
1734         /* try path-based rename first */
1735         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1736
1737         /*
1738          * Don't bother with rename by filehandle unless file is busy and
1739          * source. Note that cross directory moves do not work with
1740          * rename by filehandle to various Windows servers.
1741          */
1742         if (rc == 0 || rc != -EBUSY)
1743                 goto do_rename_exit;
1744
1745         /* Don't fall back to using SMB on SMB 2+ mount */
1746         if (server->vals->protocol_id != 0)
1747                 goto do_rename_exit;
1748
1749         /* open-file renames don't work across directories */
1750         if (to_dentry->d_parent != from_dentry->d_parent)
1751                 goto do_rename_exit;
1752
1753         oparms.tcon = tcon;
1754         oparms.cifs_sb = cifs_sb;
1755         /* open the file to be renamed -- we need DELETE perms */
1756         oparms.desired_access = DELETE;
1757         oparms.create_options = CREATE_NOT_DIR;
1758         oparms.disposition = FILE_OPEN;
1759         oparms.path = from_path;
1760         oparms.fid = &fid;
1761         oparms.reconnect = false;
1762
1763         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1764         if (rc == 0) {
1765                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1766                                 (const char *) to_dentry->d_name.name,
1767                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1768                 CIFSSMBClose(xid, tcon, fid.netfid);
1769         }
1770 do_rename_exit:
1771         cifs_put_tlink(tlink);
1772         return rc;
1773 }
1774
1775 int
1776 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1777              struct inode *target_dir, struct dentry *target_dentry,
1778              unsigned int flags)
1779 {
1780         char *from_name = NULL;
1781         char *to_name = NULL;
1782         struct cifs_sb_info *cifs_sb;
1783         struct tcon_link *tlink;
1784         struct cifs_tcon *tcon;
1785         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1786         FILE_UNIX_BASIC_INFO *info_buf_target;
1787         unsigned int xid;
1788         int rc, tmprc;
1789
1790         if (flags & ~RENAME_NOREPLACE)
1791                 return -EINVAL;
1792
1793         cifs_sb = CIFS_SB(source_dir->i_sb);
1794         tlink = cifs_sb_tlink(cifs_sb);
1795         if (IS_ERR(tlink))
1796                 return PTR_ERR(tlink);
1797         tcon = tlink_tcon(tlink);
1798
1799         xid = get_xid();
1800
1801         /*
1802          * we already have the rename sem so we do not need to
1803          * grab it again here to protect the path integrity
1804          */
1805         from_name = build_path_from_dentry(source_dentry);
1806         if (from_name == NULL) {
1807                 rc = -ENOMEM;
1808                 goto cifs_rename_exit;
1809         }
1810
1811         to_name = build_path_from_dentry(target_dentry);
1812         if (to_name == NULL) {
1813                 rc = -ENOMEM;
1814                 goto cifs_rename_exit;
1815         }
1816
1817         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1818                             to_name);
1819
1820         /*
1821          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1822          */
1823         if (flags & RENAME_NOREPLACE)
1824                 goto cifs_rename_exit;
1825
1826         if (rc == -EEXIST && tcon->unix_ext) {
1827                 /*
1828                  * Are src and dst hardlinks of same inode? We can only tell
1829                  * with unix extensions enabled.
1830                  */
1831                 info_buf_source =
1832                         kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
1833                                         GFP_KERNEL);
1834                 if (info_buf_source == NULL) {
1835                         rc = -ENOMEM;
1836                         goto cifs_rename_exit;
1837                 }
1838
1839                 info_buf_target = info_buf_source + 1;
1840                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1841                                              info_buf_source,
1842                                              cifs_sb->local_nls,
1843                                              cifs_remap(cifs_sb));
1844                 if (tmprc != 0)
1845                         goto unlink_target;
1846
1847                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1848                                              info_buf_target,
1849                                              cifs_sb->local_nls,
1850                                              cifs_remap(cifs_sb));
1851
1852                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1853                                    info_buf_target->UniqueId)) {
1854                         /* same file, POSIX says that this is a noop */
1855                         rc = 0;
1856                         goto cifs_rename_exit;
1857                 }
1858         }
1859         /*
1860          * else ... BB we could add the same check for Windows by
1861          * checking the UniqueId via FILE_INTERNAL_INFO
1862          */
1863
1864 unlink_target:
1865         /* Try unlinking the target dentry if it's not negative */
1866         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1867                 if (d_is_dir(target_dentry))
1868                         tmprc = cifs_rmdir(target_dir, target_dentry);
1869                 else
1870                         tmprc = cifs_unlink(target_dir, target_dentry);
1871                 if (tmprc)
1872                         goto cifs_rename_exit;
1873                 rc = cifs_do_rename(xid, source_dentry, from_name,
1874                                     target_dentry, to_name);
1875         }
1876
1877         /* force revalidate to go get info when needed */
1878         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1879
1880         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1881                 target_dir->i_mtime = current_time(source_dir);
1882
1883 cifs_rename_exit:
1884         kfree(info_buf_source);
1885         kfree(from_name);
1886         kfree(to_name);
1887         free_xid(xid);
1888         cifs_put_tlink(tlink);
1889         return rc;
1890 }
1891
1892 static bool
1893 cifs_inode_needs_reval(struct inode *inode)
1894 {
1895         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1896         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1897
1898         if (cifs_i->time == 0)
1899                 return true;
1900
1901         if (CIFS_CACHE_READ(cifs_i))
1902                 return false;
1903
1904         if (!lookupCacheEnabled)
1905                 return true;
1906
1907         if (!cifs_sb->actimeo)
1908                 return true;
1909
1910         if (!time_in_range(jiffies, cifs_i->time,
1911                                 cifs_i->time + cifs_sb->actimeo))
1912                 return true;
1913
1914         /* hardlinked files w/ noserverino get "special" treatment */
1915         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1916             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1917                 return true;
1918
1919         return false;
1920 }
1921
1922 /*
1923  * Zap the cache. Called when invalid_mapping flag is set.
1924  */
1925 int
1926 cifs_invalidate_mapping(struct inode *inode)
1927 {
1928         int rc = 0;
1929
1930         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1931                 rc = invalidate_inode_pages2(inode->i_mapping);
1932                 if (rc)
1933                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1934                                  __func__, inode);
1935         }
1936
1937         cifs_fscache_reset_inode_cookie(inode);
1938         return rc;
1939 }
1940
1941 /**
1942  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1943  * @word: long word containing the bit lock
1944  */
1945 static int
1946 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
1947 {
1948         freezable_schedule_unsafe();
1949         if (signal_pending_state(mode, current))
1950                 return -ERESTARTSYS;
1951         return 0;
1952 }
1953
1954 int
1955 cifs_revalidate_mapping(struct inode *inode)
1956 {
1957         int rc;
1958         unsigned long *flags = &CIFS_I(inode)->flags;
1959
1960         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1961                                      TASK_KILLABLE);
1962         if (rc)
1963                 return rc;
1964
1965         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1966                 rc = cifs_invalidate_mapping(inode);
1967                 if (rc)
1968                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1969         }
1970
1971         clear_bit_unlock(CIFS_INO_LOCK, flags);
1972         smp_mb__after_atomic();
1973         wake_up_bit(flags, CIFS_INO_LOCK);
1974
1975         return rc;
1976 }
1977
1978 int
1979 cifs_zap_mapping(struct inode *inode)
1980 {
1981         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1982         return cifs_revalidate_mapping(inode);
1983 }
1984
1985 int cifs_revalidate_file_attr(struct file *filp)
1986 {
1987         int rc = 0;
1988         struct inode *inode = file_inode(filp);
1989         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1990
1991         if (!cifs_inode_needs_reval(inode))
1992                 return rc;
1993
1994         if (tlink_tcon(cfile->tlink)->unix_ext)
1995                 rc = cifs_get_file_info_unix(filp);
1996         else
1997                 rc = cifs_get_file_info(filp);
1998
1999         return rc;
2000 }
2001
2002 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2003 {
2004         unsigned int xid;
2005         int rc = 0;
2006         struct inode *inode = d_inode(dentry);
2007         struct super_block *sb = dentry->d_sb;
2008         char *full_path = NULL;
2009
2010         if (inode == NULL)
2011                 return -ENOENT;
2012
2013         if (!cifs_inode_needs_reval(inode))
2014                 return rc;
2015
2016         xid = get_xid();
2017
2018         /* can not safely grab the rename sem here if rename calls revalidate
2019            since that would deadlock */
2020         full_path = build_path_from_dentry(dentry);
2021         if (full_path == NULL) {
2022                 rc = -ENOMEM;
2023                 goto out;
2024         }
2025
2026         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2027                  full_path, inode, inode->i_count.counter,
2028                  dentry, cifs_get_time(dentry), jiffies);
2029
2030         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2031                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2032         else
2033                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2034                                          xid, NULL);
2035
2036 out:
2037         kfree(full_path);
2038         free_xid(xid);
2039         return rc;
2040 }
2041
2042 int cifs_revalidate_file(struct file *filp)
2043 {
2044         int rc;
2045         struct inode *inode = file_inode(filp);
2046
2047         rc = cifs_revalidate_file_attr(filp);
2048         if (rc)
2049                 return rc;
2050
2051         return cifs_revalidate_mapping(inode);
2052 }
2053
2054 /* revalidate a dentry's inode attributes */
2055 int cifs_revalidate_dentry(struct dentry *dentry)
2056 {
2057         int rc;
2058         struct inode *inode = d_inode(dentry);
2059
2060         rc = cifs_revalidate_dentry_attr(dentry);
2061         if (rc)
2062                 return rc;
2063
2064         return cifs_revalidate_mapping(inode);
2065 }
2066
2067 int cifs_getattr(const struct path *path, struct kstat *stat,
2068                  u32 request_mask, unsigned int flags)
2069 {
2070         struct dentry *dentry = path->dentry;
2071         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2072         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2073         struct inode *inode = d_inode(dentry);
2074         int rc;
2075
2076         /*
2077          * We need to be sure that all dirty pages are written and the server
2078          * has actual ctime, mtime and file length.
2079          */
2080         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2081             inode->i_mapping->nrpages != 0) {
2082                 rc = filemap_fdatawait(inode->i_mapping);
2083                 if (rc) {
2084                         mapping_set_error(inode->i_mapping, rc);
2085                         return rc;
2086                 }
2087         }
2088
2089         rc = cifs_revalidate_dentry_attr(dentry);
2090         if (rc)
2091                 return rc;
2092
2093         generic_fillattr(inode, stat);
2094         stat->blksize = cifs_sb->bsize;
2095         stat->ino = CIFS_I(inode)->uniqueid;
2096
2097         /* old CIFS Unix Extensions doesn't return create time */
2098         if (CIFS_I(inode)->createtime) {
2099                 stat->result_mask |= STATX_BTIME;
2100                 stat->btime =
2101                       cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2102         }
2103
2104         stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2105         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2106                 stat->attributes |= STATX_ATTR_COMPRESSED;
2107         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2108                 stat->attributes |= STATX_ATTR_ENCRYPTED;
2109
2110         /*
2111          * If on a multiuser mount without unix extensions or cifsacl being
2112          * enabled, and the admin hasn't overridden them, set the ownership
2113          * to the fsuid/fsgid of the current process.
2114          */
2115         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2116             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2117             !tcon->unix_ext) {
2118                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2119                         stat->uid = current_fsuid();
2120                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2121                         stat->gid = current_fsgid();
2122         }
2123         return rc;
2124 }
2125
2126 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2127                 u64 len)
2128 {
2129         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2130         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2131         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2132         struct TCP_Server_Info *server = tcon->ses->server;
2133         struct cifsFileInfo *cfile;
2134         int rc;
2135
2136         /*
2137          * We need to be sure that all dirty pages are written as they
2138          * might fill holes on the server.
2139          */
2140         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2141             inode->i_mapping->nrpages != 0) {
2142                 rc = filemap_fdatawait(inode->i_mapping);
2143                 if (rc) {
2144                         mapping_set_error(inode->i_mapping, rc);
2145                         return rc;
2146                 }
2147         }
2148
2149         cfile = find_readable_file(cifs_i, false);
2150         if (cfile == NULL)
2151                 return -EINVAL;
2152
2153         if (server->ops->fiemap) {
2154                 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2155                 cifsFileInfo_put(cfile);
2156                 return rc;
2157         }
2158
2159         cifsFileInfo_put(cfile);
2160         return -ENOTSUPP;
2161 }
2162
2163 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2164 {
2165         pgoff_t index = from >> PAGE_SHIFT;
2166         unsigned offset = from & (PAGE_SIZE - 1);
2167         struct page *page;
2168         int rc = 0;
2169
2170         page = grab_cache_page(mapping, index);
2171         if (!page)
2172                 return -ENOMEM;
2173
2174         zero_user_segment(page, offset, PAGE_SIZE);
2175         unlock_page(page);
2176         put_page(page);
2177         return rc;
2178 }
2179
2180 static void cifs_setsize(struct inode *inode, loff_t offset)
2181 {
2182         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2183
2184         spin_lock(&inode->i_lock);
2185         i_size_write(inode, offset);
2186         spin_unlock(&inode->i_lock);
2187
2188         /* Cached inode must be refreshed on truncate */
2189         cifs_i->time = 0;
2190         truncate_pagecache(inode, offset);
2191 }
2192
2193 static int
2194 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2195                    unsigned int xid, char *full_path)
2196 {
2197         int rc;
2198         struct cifsFileInfo *open_file;
2199         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2200         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2201         struct tcon_link *tlink = NULL;
2202         struct cifs_tcon *tcon = NULL;
2203         struct TCP_Server_Info *server;
2204
2205         /*
2206          * To avoid spurious oplock breaks from server, in the case of
2207          * inodes that we already have open, avoid doing path based
2208          * setting of file size if we can do it by handle.
2209          * This keeps our caching token (oplock) and avoids timeouts
2210          * when the local oplock break takes longer to flush
2211          * writebehind data than the SMB timeout for the SetPathInfo
2212          * request would allow
2213          */
2214         open_file = find_writable_file(cifsInode, true);
2215         if (open_file) {
2216                 tcon = tlink_tcon(open_file->tlink);
2217                 server = tcon->ses->server;
2218                 if (server->ops->set_file_size)
2219                         rc = server->ops->set_file_size(xid, tcon, open_file,
2220                                                         attrs->ia_size, false);
2221                 else
2222                         rc = -ENOSYS;
2223                 cifsFileInfo_put(open_file);
2224                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2225         } else
2226                 rc = -EINVAL;
2227
2228         if (!rc)
2229                 goto set_size_out;
2230
2231         if (tcon == NULL) {
2232                 tlink = cifs_sb_tlink(cifs_sb);
2233                 if (IS_ERR(tlink))
2234                         return PTR_ERR(tlink);
2235                 tcon = tlink_tcon(tlink);
2236                 server = tcon->ses->server;
2237         }
2238
2239         /*
2240          * Set file size by pathname rather than by handle either because no
2241          * valid, writeable file handle for it was found or because there was
2242          * an error setting it by handle.
2243          */
2244         if (server->ops->set_path_size)
2245                 rc = server->ops->set_path_size(xid, tcon, full_path,
2246                                                 attrs->ia_size, cifs_sb, false);
2247         else
2248                 rc = -ENOSYS;
2249         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2250
2251         if (tlink)
2252                 cifs_put_tlink(tlink);
2253
2254 set_size_out:
2255         if (rc == 0) {
2256                 cifsInode->server_eof = attrs->ia_size;
2257                 cifs_setsize(inode, attrs->ia_size);
2258                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2259         }
2260
2261         return rc;
2262 }
2263
2264 static int
2265 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2266 {
2267         int rc;
2268         unsigned int xid;
2269         char *full_path = NULL;
2270         struct inode *inode = d_inode(direntry);
2271         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2272         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2273         struct tcon_link *tlink;
2274         struct cifs_tcon *pTcon;
2275         struct cifs_unix_set_info_args *args = NULL;
2276         struct cifsFileInfo *open_file;
2277
2278         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2279                  direntry, attrs->ia_valid);
2280
2281         xid = get_xid();
2282
2283         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2284                 attrs->ia_valid |= ATTR_FORCE;
2285
2286         rc = setattr_prepare(direntry, attrs);
2287         if (rc < 0)
2288                 goto out;
2289
2290         full_path = build_path_from_dentry(direntry);
2291         if (full_path == NULL) {
2292                 rc = -ENOMEM;
2293                 goto out;
2294         }
2295
2296         /*
2297          * Attempt to flush data before changing attributes. We need to do
2298          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2299          * ownership or mode then we may also need to do this. Here, we take
2300          * the safe way out and just do the flush on all setattr requests. If
2301          * the flush returns error, store it to report later and continue.
2302          *
2303          * BB: This should be smarter. Why bother flushing pages that
2304          * will be truncated anyway? Also, should we error out here if
2305          * the flush returns error?
2306          */
2307         rc = filemap_write_and_wait(inode->i_mapping);
2308         if (is_interrupt_error(rc)) {
2309                 rc = -ERESTARTSYS;
2310                 goto out;
2311         }
2312
2313         mapping_set_error(inode->i_mapping, rc);
2314         rc = 0;
2315
2316         if (attrs->ia_valid & ATTR_SIZE) {
2317                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2318                 if (rc != 0)
2319                         goto out;
2320         }
2321
2322         /* skip mode change if it's just for clearing setuid/setgid */
2323         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2324                 attrs->ia_valid &= ~ATTR_MODE;
2325
2326         args = kmalloc(sizeof(*args), GFP_KERNEL);
2327         if (args == NULL) {
2328                 rc = -ENOMEM;
2329                 goto out;
2330         }
2331
2332         /* set up the struct */
2333         if (attrs->ia_valid & ATTR_MODE)
2334                 args->mode = attrs->ia_mode;
2335         else
2336                 args->mode = NO_CHANGE_64;
2337
2338         if (attrs->ia_valid & ATTR_UID)
2339                 args->uid = attrs->ia_uid;
2340         else
2341                 args->uid = INVALID_UID; /* no change */
2342
2343         if (attrs->ia_valid & ATTR_GID)
2344                 args->gid = attrs->ia_gid;
2345         else
2346                 args->gid = INVALID_GID; /* no change */
2347
2348         if (attrs->ia_valid & ATTR_ATIME)
2349                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2350         else
2351                 args->atime = NO_CHANGE_64;
2352
2353         if (attrs->ia_valid & ATTR_MTIME)
2354                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2355         else
2356                 args->mtime = NO_CHANGE_64;
2357
2358         if (attrs->ia_valid & ATTR_CTIME)
2359                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2360         else
2361                 args->ctime = NO_CHANGE_64;
2362
2363         args->device = 0;
2364         open_file = find_writable_file(cifsInode, true);
2365         if (open_file) {
2366                 u16 nfid = open_file->fid.netfid;
2367                 u32 npid = open_file->pid;
2368                 pTcon = tlink_tcon(open_file->tlink);
2369                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2370                 cifsFileInfo_put(open_file);
2371         } else {
2372                 tlink = cifs_sb_tlink(cifs_sb);
2373                 if (IS_ERR(tlink)) {
2374                         rc = PTR_ERR(tlink);
2375                         goto out;
2376                 }
2377                 pTcon = tlink_tcon(tlink);
2378                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2379                                     cifs_sb->local_nls,
2380                                     cifs_remap(cifs_sb));
2381                 cifs_put_tlink(tlink);
2382         }
2383
2384         if (rc)
2385                 goto out;
2386
2387         if ((attrs->ia_valid & ATTR_SIZE) &&
2388             attrs->ia_size != i_size_read(inode))
2389                 truncate_setsize(inode, attrs->ia_size);
2390
2391         setattr_copy(inode, attrs);
2392         mark_inode_dirty(inode);
2393
2394         /* force revalidate when any of these times are set since some
2395            of the fs types (eg ext3, fat) do not have fine enough
2396            time granularity to match protocol, and we do not have a
2397            a way (yet) to query the server fs's time granularity (and
2398            whether it rounds times down).
2399         */
2400         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2401                 cifsInode->time = 0;
2402 out:
2403         kfree(args);
2404         kfree(full_path);
2405         free_xid(xid);
2406         return rc;
2407 }
2408
2409 static int
2410 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2411 {
2412         unsigned int xid;
2413         kuid_t uid = INVALID_UID;
2414         kgid_t gid = INVALID_GID;
2415         struct inode *inode = d_inode(direntry);
2416         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2417         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2418         struct cifsFileInfo *wfile;
2419         struct cifs_tcon *tcon;
2420         char *full_path = NULL;
2421         int rc = -EACCES;
2422         __u32 dosattr = 0;
2423         __u64 mode = NO_CHANGE_64;
2424
2425         xid = get_xid();
2426
2427         cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2428                  direntry, attrs->ia_valid);
2429
2430         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2431                 attrs->ia_valid |= ATTR_FORCE;
2432
2433         rc = setattr_prepare(direntry, attrs);
2434         if (rc < 0) {
2435                 free_xid(xid);
2436                 return rc;
2437         }
2438
2439         full_path = build_path_from_dentry(direntry);
2440         if (full_path == NULL) {
2441                 rc = -ENOMEM;
2442                 free_xid(xid);
2443                 return rc;
2444         }
2445
2446         /*
2447          * Attempt to flush data before changing attributes. We need to do
2448          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2449          * ownership or mode then we may also need to do this. Here, we take
2450          * the safe way out and just do the flush on all setattr requests. If
2451          * the flush returns error, store it to report later and continue.
2452          *
2453          * BB: This should be smarter. Why bother flushing pages that
2454          * will be truncated anyway? Also, should we error out here if
2455          * the flush returns error?
2456          */
2457         rc = filemap_write_and_wait(inode->i_mapping);
2458         if (is_interrupt_error(rc)) {
2459                 rc = -ERESTARTSYS;
2460                 goto cifs_setattr_exit;
2461         }
2462
2463         mapping_set_error(inode->i_mapping, rc);
2464         rc = 0;
2465
2466         if (attrs->ia_valid & ATTR_MTIME) {
2467                 rc = cifs_get_writable_file(cifsInode, false, &wfile);
2468                 if (!rc) {
2469                         tcon = tlink_tcon(wfile->tlink);
2470                         rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2471                         cifsFileInfo_put(wfile);
2472                         if (rc)
2473                                 return rc;
2474                 } else if (rc != -EBADF)
2475                         return rc;
2476                 else
2477                         rc = 0;
2478         }
2479
2480         if (attrs->ia_valid & ATTR_SIZE) {
2481                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2482                 if (rc != 0)
2483                         goto cifs_setattr_exit;
2484         }
2485
2486         if (attrs->ia_valid & ATTR_UID)
2487                 uid = attrs->ia_uid;
2488
2489         if (attrs->ia_valid & ATTR_GID)
2490                 gid = attrs->ia_gid;
2491
2492         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2493             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2494                 if (uid_valid(uid) || gid_valid(gid)) {
2495                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2496                                                         uid, gid);
2497                         if (rc) {
2498                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2499                                          __func__, rc);
2500                                 goto cifs_setattr_exit;
2501                         }
2502                 }
2503         } else
2504         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2505                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2506
2507         /* skip mode change if it's just for clearing setuid/setgid */
2508         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2509                 attrs->ia_valid &= ~ATTR_MODE;
2510
2511         if (attrs->ia_valid & ATTR_MODE) {
2512                 mode = attrs->ia_mode;
2513                 rc = 0;
2514                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2515                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2516                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2517                                                 INVALID_UID, INVALID_GID);
2518                         if (rc) {
2519                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2520                                          __func__, rc);
2521                                 goto cifs_setattr_exit;
2522                         }
2523                 } else
2524                 if (((mode & S_IWUGO) == 0) &&
2525                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2526
2527                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2528
2529                         /* fix up mode if we're not using dynperm */
2530                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2531                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2532                 } else if ((mode & S_IWUGO) &&
2533                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2534
2535                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2536                         /* Attributes of 0 are ignored */
2537                         if (dosattr == 0)
2538                                 dosattr |= ATTR_NORMAL;
2539
2540                         /* reset local inode permissions to normal */
2541                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2542                                 attrs->ia_mode &= ~(S_IALLUGO);
2543                                 if (S_ISDIR(inode->i_mode))
2544                                         attrs->ia_mode |=
2545                                                 cifs_sb->mnt_dir_mode;
2546                                 else
2547                                         attrs->ia_mode |=
2548                                                 cifs_sb->mnt_file_mode;
2549                         }
2550                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2551                         /* ignore mode change - ATTR_READONLY hasn't changed */
2552                         attrs->ia_valid &= ~ATTR_MODE;
2553                 }
2554         }
2555
2556         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2557             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2558                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2559                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2560
2561                 /* Even if error on time set, no sense failing the call if
2562                 the server would set the time to a reasonable value anyway,
2563                 and this check ensures that we are not being called from
2564                 sys_utimes in which case we ought to fail the call back to
2565                 the user when the server rejects the call */
2566                 if ((rc) && (attrs->ia_valid &
2567                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2568                         rc = 0;
2569         }
2570
2571         /* do not need local check to inode_check_ok since the server does
2572            that */
2573         if (rc)
2574                 goto cifs_setattr_exit;
2575
2576         if ((attrs->ia_valid & ATTR_SIZE) &&
2577             attrs->ia_size != i_size_read(inode))
2578                 truncate_setsize(inode, attrs->ia_size);
2579
2580         setattr_copy(inode, attrs);
2581         mark_inode_dirty(inode);
2582
2583 cifs_setattr_exit:
2584         kfree(full_path);
2585         free_xid(xid);
2586         return rc;
2587 }
2588
2589 int
2590 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2591 {
2592         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2593         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2594
2595         if (pTcon->unix_ext)
2596                 return cifs_setattr_unix(direntry, attrs);
2597
2598         return cifs_setattr_nounix(direntry, attrs);
2599
2600         /* BB: add cifs_setattr_legacy for really old servers */
2601 }
2602
2603 #if 0
2604 void cifs_delete_inode(struct inode *inode)
2605 {
2606         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2607         /* may have to add back in if and when safe distributed caching of
2608            directories added e.g. via FindNotify */
2609 }
2610 #endif