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