fs/cifs/inode.c

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