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