fs/cifs/inode.c

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