fs/cifs/inode.c

   1 /*
   2  *   fs/cifs/inode.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2010
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/stat.h>
  23 #include <linux/slab.h>
  24 #include <linux/pagemap.h>
  25 #include <linux/freezer.h>
  26 #include <linux/sched/signal.h>
  27 #include <linux/wait_bit.h>
  28 #include <linux/fiemap.h>
  29
  30 #include <asm/div64.h>
  31 #include "cifsfs.h"
  32 #include "cifspdu.h"
  33 #include "cifsglob.h"
  34 #include "cifsproto.h"
  35 #include "smb2proto.h"
  36 #include "cifs_debug.h"
  37 #include "cifs_fs_sb.h"
  38 #include "cifs_unicode.h"
  39 #include "fscache.h"
  40
  41
  42 static void cifs_set_ops(struct inode *inode)
  43 {
  44         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  45
  46         switch (inode->i_mode & S_IFMT) {
  47         case S_IFREG:
  48                 inode->i_op = &cifs_file_inode_ops;
  49                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  50                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  51                                 inode->i_fop = &cifs_file_direct_nobrl_ops;
  52                         else
  53                                 inode->i_fop = &cifs_file_direct_ops;
  54                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
  55                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  56                                 inode->i_fop = &cifs_file_strict_nobrl_ops;
  57                         else
  58                                 inode->i_fop = &cifs_file_strict_ops;
  59                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  60                         inode->i_fop = &cifs_file_nobrl_ops;
  61                 else { /* not direct, send byte range locks */
  62                         inode->i_fop = &cifs_file_ops;
  63                 }
  64
  65                 /* check if server can support readpages */
  66                 if (cifs_sb_master_tcon(cifs_sb)->ses->server->max_read <
  67                                 PAGE_SIZE + MAX_CIFS_HDR_SIZE)
  68                         inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  69                 else
  70                         inode->i_data.a_ops = &cifs_addr_ops;
  71                 break;
  72         case S_IFDIR:
  73 #ifdef CONFIG_CIFS_DFS_UPCALL
  74                 if (IS_AUTOMOUNT(inode)) {
  75                         inode->i_op = &cifs_dfs_referral_inode_operations;
  76                 } else {
  77 #else /* NO DFS support, treat as a directory */
  78                 {
  79 #endif
  80                         inode->i_op = &cifs_dir_inode_ops;
  81                         inode->i_fop = &cifs_dir_ops;
  82                 }
  83                 break;
  84         case S_IFLNK:
  85                 inode->i_op = &cifs_symlink_inode_ops;
  86                 break;
  87         default:
  88                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
  89                 break;
  90         }
  91 }
  92
  93 /* check inode attributes against fattr. If they don't match, tag the
  94  * inode for cache invalidation
  95  */
  96 static void
  97 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
  98 {
  99         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 100
 101         cifs_dbg(FYI, "%s: revalidating inode %llu\n",
 102                  __func__, cifs_i->uniqueid);
 103
 104         if (inode->i_state & I_NEW) {
 105                 cifs_dbg(FYI, "%s: inode %llu is new\n",
 106                          __func__, cifs_i->uniqueid);
 107                 return;
 108         }
 109
 110         /* don't bother with revalidation if we have an oplock */
 111         if (CIFS_CACHE_READ(cifs_i)) {
 112                 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
 113                          __func__, cifs_i->uniqueid);
 114                 return;
 115         }
 116
 117          /* revalidate if mtime or size have changed */
 118         fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
 119         if (timespec64_equal(&inode->i_mtime, &fattr->cf_mtime) &&
 120             cifs_i->server_eof == fattr->cf_eof) {
 121                 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
 122                          __func__, cifs_i->uniqueid);
 123                 return;
 124         }
 125
 126         cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
 127                  __func__, cifs_i->uniqueid);
 128         set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
 129 }
 130
 131 /*
 132  * copy nlink to the inode, unless it wasn't provided.  Provide
 133  * sane values if we don't have an existing one and none was provided
 134  */
 135 static void
 136 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 137 {
 138         /*
 139          * if we're in a situation where we can't trust what we
 140          * got from the server (readdir, some non-unix cases)
 141          * fake reasonable values
 142          */
 143         if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
 144                 /* only provide fake values on a new inode */
 145                 if (inode->i_state & I_NEW) {
 146                         if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
 147                                 set_nlink(inode, 2);
 148                         else
 149                                 set_nlink(inode, 1);
 150                 }
 151                 return;
 152         }
 153
 154         /* we trust the server, so update it */
 155         set_nlink(inode, fattr->cf_nlink);
 156 }
 157
 158 /* populate an inode with info from a cifs_fattr struct */
 159 void
 160 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
 161 {
 162         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 163         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 164
 165         cifs_revalidate_cache(inode, fattr);
 166
 167         spin_lock(&inode->i_lock);
 168         fattr->cf_mtime = timestamp_truncate(fattr->cf_mtime, inode);
 169         fattr->cf_atime = timestamp_truncate(fattr->cf_atime, inode);
 170         fattr->cf_ctime = timestamp_truncate(fattr->cf_ctime, inode);
 171         /* we do not want atime to be less than mtime, it broke some apps */
 172         if (timespec64_compare(&fattr->cf_atime, &fattr->cf_mtime) < 0)
 173                 inode->i_atime = fattr->cf_mtime;
 174         else
 175                 inode->i_atime = fattr->cf_atime;
 176         inode->i_mtime = fattr->cf_mtime;
 177         inode->i_ctime = fattr->cf_ctime;
 178         inode->i_rdev = fattr->cf_rdev;
 179         cifs_nlink_fattr_to_inode(inode, fattr);
 180         inode->i_uid = fattr->cf_uid;
 181         inode->i_gid = fattr->cf_gid;
 182
 183         /* if dynperm is set, don't clobber existing mode */
 184         if (inode->i_state & I_NEW ||
 185             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
 186                 inode->i_mode = fattr->cf_mode;
 187
 188         cifs_i->cifsAttrs = fattr->cf_cifsattrs;
 189
 190         if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
 191                 cifs_i->time = 0;
 192         else
 193                 cifs_i->time = jiffies;
 194
 195         if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
 196                 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 197         else
 198                 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
 199
 200         cifs_i->server_eof = fattr->cf_eof;
 201         /*
 202          * Can't safely change the file size here if the client is writing to
 203          * it due to potential races.
 204          */
 205         if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
 206                 i_size_write(inode, fattr->cf_eof);
 207
 208                 /*
 209                  * i_blocks is not related to (i_size / i_blksize),
 210                  * but instead 512 byte (2**9) size is required for
 211                  * calculating num blocks.
 212                  */
 213                 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
 214         }
 215         spin_unlock(&inode->i_lock);
 216
 217         if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
 218                 inode->i_flags |= S_AUTOMOUNT;
 219         if (inode->i_state & I_NEW)
 220                 cifs_set_ops(inode);
 221 }
 222
 223 void
 224 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
 225 {
 226         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 227
 228         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
 229                 return;
 230
 231         fattr->cf_uniqueid = iunique(sb, ROOT_I);
 232 }
 233
 234 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
 235 void
 236 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
 237                          struct cifs_sb_info *cifs_sb)
 238 {
 239         memset(fattr, 0, sizeof(*fattr));
 240         fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
 241         fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
 242         fattr->cf_eof = le64_to_cpu(info->EndOfFile);
 243
 244         fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
 245         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
 246         fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
 247         /* old POSIX extensions don't get create time */
 248
 249         fattr->cf_mode = le64_to_cpu(info->Permissions);
 250
 251         /*
 252          * Since we set the inode type below we need to mask off
 253          * to avoid strange results if bits set above.
 254          */
 255         fattr->cf_mode &= ~S_IFMT;
 256         switch (le32_to_cpu(info->Type)) {
 257         case UNIX_FILE:
 258                 fattr->cf_mode |= S_IFREG;
 259                 fattr->cf_dtype = DT_REG;
 260                 break;
 261         case UNIX_SYMLINK:
 262                 fattr->cf_mode |= S_IFLNK;
 263                 fattr->cf_dtype = DT_LNK;
 264                 break;
 265         case UNIX_DIR:
 266                 fattr->cf_mode |= S_IFDIR;
 267                 fattr->cf_dtype = DT_DIR;
 268                 break;
 269         case UNIX_CHARDEV:
 270                 fattr->cf_mode |= S_IFCHR;
 271                 fattr->cf_dtype = DT_CHR;
 272                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 273                                        le64_to_cpu(info->DevMinor) & MINORMASK);
 274                 break;
 275         case UNIX_BLOCKDEV:
 276                 fattr->cf_mode |= S_IFBLK;
 277                 fattr->cf_dtype = DT_BLK;
 278                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 279                                        le64_to_cpu(info->DevMinor) & MINORMASK);
 280                 break;
 281         case UNIX_FIFO:
 282                 fattr->cf_mode |= S_IFIFO;
 283                 fattr->cf_dtype = DT_FIFO;
 284                 break;
 285         case UNIX_SOCKET:
 286                 fattr->cf_mode |= S_IFSOCK;
 287                 fattr->cf_dtype = DT_SOCK;
 288                 break;
 289         default:
 290                 /* safest to call it a file if we do not know */
 291                 fattr->cf_mode |= S_IFREG;
 292                 fattr->cf_dtype = DT_REG;
 293                 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
 294                 break;
 295         }
 296
 297         fattr->cf_uid = cifs_sb->mnt_uid;
 298         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
 299                 u64 id = le64_to_cpu(info->Uid);
 300                 if (id < ((uid_t)-1)) {
 301                         kuid_t uid = make_kuid(&init_user_ns, id);
 302                         if (uid_valid(uid))
 303                                 fattr->cf_uid = uid;
 304                 }
 305         }
 306
 307         fattr->cf_gid = cifs_sb->mnt_gid;
 308         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
 309                 u64 id = le64_to_cpu(info->Gid);
 310                 if (id < ((gid_t)-1)) {
 311                         kgid_t gid = make_kgid(&init_user_ns, id);
 312                         if (gid_valid(gid))
 313                                 fattr->cf_gid = gid;
 314                 }
 315         }
 316
 317         fattr->cf_nlink = le64_to_cpu(info->Nlinks);
 318 }
 319
 320 /*
 321  * Fill a cifs_fattr struct with fake inode info.
 322  *
 323  * Needed to setup cifs_fattr data for the directory which is the
 324  * junction to the new submount (ie to setup the fake directory
 325  * which represents a DFS referral).
 326  */
 327 static void
 328 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
 329 {
 330         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 331
 332         cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
 333
 334         memset(fattr, 0, sizeof(*fattr));
 335         fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
 336         fattr->cf_uid = cifs_sb->mnt_uid;
 337         fattr->cf_gid = cifs_sb->mnt_gid;
 338         ktime_get_coarse_real_ts64(&fattr->cf_mtime);
 339         fattr->cf_atime = fattr->cf_ctime = fattr->cf_mtime;
 340         fattr->cf_nlink = 2;
 341         fattr->cf_flags = CIFS_FATTR_DFS_REFERRAL;
 342 }
 343
 344 static int
 345 cifs_get_file_info_unix(struct file *filp)
 346 {
 347         int rc;
 348         unsigned int xid;
 349         FILE_UNIX_BASIC_INFO find_data;
 350         struct cifs_fattr fattr;
 351         struct inode *inode = file_inode(filp);
 352         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 353         struct cifsFileInfo *cfile = filp->private_data;
 354         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 355
 356         xid = get_xid();
 357         rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
 358         if (!rc) {
 359                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 360         } else if (rc == -EREMOTE) {
 361                 cifs_create_dfs_fattr(&fattr, inode->i_sb);
 362                 rc = 0;
 363         }
 364
 365         cifs_fattr_to_inode(inode, &fattr);
 366         free_xid(xid);
 367         return rc;
 368 }
 369
 370 int cifs_get_inode_info_unix(struct inode **pinode,
 371                              const unsigned char *full_path,
 372                              struct super_block *sb, unsigned int xid)
 373 {
 374         int rc;
 375         FILE_UNIX_BASIC_INFO find_data;
 376         struct cifs_fattr fattr;
 377         struct cifs_tcon *tcon;
 378         struct tcon_link *tlink;
 379         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 380
 381         cifs_dbg(FYI, "Getting info on %s\n", full_path);
 382
 383         tlink = cifs_sb_tlink(cifs_sb);
 384         if (IS_ERR(tlink))
 385                 return PTR_ERR(tlink);
 386         tcon = tlink_tcon(tlink);
 387
 388         /* could have done a find first instead but this returns more info */
 389         rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
 390                                   cifs_sb->local_nls, cifs_remap(cifs_sb));
 391         cifs_put_tlink(tlink);
 392
 393         if (!rc) {
 394                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
 395         } else if (rc == -EREMOTE) {
 396                 cifs_create_dfs_fattr(&fattr, sb);
 397                 rc = 0;
 398         } else {
 399                 return rc;
 400         }
 401
 402         /* check for Minshall+French symlinks */
 403         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
 404                 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
 405                                              full_path);
 406                 if (tmprc)
 407                         cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
 408         }
 409
 410         if (*pinode == NULL) {
 411                 /* get new inode */
 412                 cifs_fill_uniqueid(sb, &fattr);
 413                 *pinode = cifs_iget(sb, &fattr);
 414                 if (!*pinode)
 415                         rc = -ENOMEM;
 416         } else {
 417                 /* we already have inode, update it */
 418
 419                 /* if uniqueid is different, return error */
 420                 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
 421                     CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
 422                         CIFS_I(*pinode)->time = 0; /* force reval */
 423                         rc = -ESTALE;
 424                         goto cgiiu_exit;
 425                 }
 426
 427                 /* if filetype is different, return error */
 428                 if (unlikely(((*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 TCP_Server_Info *server;
1090         struct tcon_link *tlink;
1091         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1092         bool adjust_tz = false;
1093         struct cifs_fattr fattr = {0};
1094         bool symlink = false;
1095         struct smb311_posix_qinfo *data = NULL;
1096         int rc = 0;
1097         int tmprc = 0;
1098
1099         tlink = cifs_sb_tlink(cifs_sb);
1100         if (IS_ERR(tlink))
1101                 return PTR_ERR(tlink);
1102         tcon = tlink_tcon(tlink);
1103         server = tcon->ses->server;
1104
1105         /*
1106          * 1. Fetch file metadata
1107          */
1108
1109         if (is_inode_cache_good(*inode)) {
1110                 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
1111                 goto out;
1112         }
1113         data = kmalloc(sizeof(struct smb311_posix_qinfo), GFP_KERNEL);
1114         if (!data) {
1115                 rc = -ENOMEM;
1116                 goto out;
1117         }
1118
1119         rc = smb311_posix_query_path_info(xid, tcon, cifs_sb,
1120                                                   full_path, data,
1121                                                   &adjust_tz, &symlink);
1122
1123         /*
1124          * 2. Convert it to internal cifs metadata (fattr)
1125          */
1126
1127         switch (rc) {
1128         case 0:
1129                 smb311_posix_info_to_fattr(&fattr, data, sb, adjust_tz, symlink);
1130                 break;
1131         case -EREMOTE:
1132                 /* DFS link, no metadata available on this server */
1133                 cifs_create_dfs_fattr(&fattr, sb);
1134                 rc = 0;
1135                 break;
1136         case -EACCES:
1137                 /*
1138                  * For SMB2 and later the backup intent flag
1139                  * is already sent if needed on open and there
1140                  * is no path based FindFirst operation to use
1141                  * to retry with so nothing we can do, bail out
1142                  */
1143                 goto out;
1144         default:
1145                 cifs_dbg(FYI, "%s: unhandled err rc %d\n", __func__, rc);
1146                 goto out;
1147         }
1148
1149
1150         /*
1151          * 3. Tweak fattr based on mount options
1152          */
1153
1154         /* check for Minshall+French symlinks */
1155         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
1156                 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
1157                                          full_path);
1158                 if (tmprc)
1159                         cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
1160         }
1161
1162         /*
1163          * 4. Update inode with final fattr data
1164          */
1165
1166         if (!*inode) {
1167                 *inode = cifs_iget(sb, &fattr);
1168                 if (!*inode)
1169                         rc = -ENOMEM;
1170         } else {
1171                 /* we already have inode, update it */
1172
1173                 /* if uniqueid is different, return error */
1174                 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
1175                     CIFS_I(*inode)->uniqueid != fattr.cf_uniqueid)) {
1176                         CIFS_I(*inode)->time = 0; /* force reval */
1177                         rc = -ESTALE;
1178                         goto out;
1179                 }
1180
1181                 /* if filetype is different, return error */
1182                 if (unlikely(((*inode)->i_mode & S_IFMT) !=
1183                     (fattr.cf_mode & S_IFMT))) {
1184                         CIFS_I(*inode)->time = 0; /* force reval */
1185                         rc = -ESTALE;
1186                         goto out;
1187                 }
1188
1189                 cifs_fattr_to_inode(*inode, &fattr);
1190         }
1191 out:
1192         cifs_put_tlink(tlink);
1193         kfree(data);
1194         return rc;
1195 }
1196
1197
1198 static const struct inode_operations cifs_ipc_inode_ops = {
1199         .lookup = cifs_lookup,
1200 };
1201
1202 static int
1203 cifs_find_inode(struct inode *inode, void *opaque)
1204 {
1205         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1206
1207         /* don't match inode with different uniqueid */
1208         if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
1209                 return 0;
1210
1211         /* use createtime like an i_generation field */
1212         if (CIFS_I(inode)->createtime != fattr->cf_createtime)
1213                 return 0;
1214
1215         /* don't match inode of different type */
1216         if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
1217                 return 0;
1218
1219         /* if it's not a directory or has no dentries, then flag it */
1220         if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
1221                 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
1222
1223         return 1;
1224 }
1225
1226 static int
1227 cifs_init_inode(struct inode *inode, void *opaque)
1228 {
1229         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
1230
1231         CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
1232         CIFS_I(inode)->createtime = fattr->cf_createtime;
1233         return 0;
1234 }
1235
1236 /*
1237  * walk dentry list for an inode and report whether it has aliases that
1238  * are hashed. We use this to determine if a directory inode can actually
1239  * be used.
1240  */
1241 static bool
1242 inode_has_hashed_dentries(struct inode *inode)
1243 {
1244         struct dentry *dentry;
1245
1246         spin_lock(&inode->i_lock);
1247         hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
1248                 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
1249                         spin_unlock(&inode->i_lock);
1250                         return true;
1251                 }
1252         }
1253         spin_unlock(&inode->i_lock);
1254         return false;
1255 }
1256
1257 /* Given fattrs, get a corresponding inode */
1258 struct inode *
1259 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
1260 {
1261         unsigned long hash;
1262         struct inode *inode;
1263
1264 retry_iget5_locked:
1265         cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
1266
1267         /* hash down to 32-bits on 32-bit arch */
1268         hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
1269
1270         inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
1271         if (inode) {
1272                 /* was there a potentially problematic inode collision? */
1273                 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
1274                         fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
1275
1276                         if (inode_has_hashed_dentries(inode)) {
1277                                 cifs_autodisable_serverino(CIFS_SB(sb));
1278                                 iput(inode);
1279                                 fattr->cf_uniqueid = iunique(sb, ROOT_I);
1280                                 goto retry_iget5_locked;
1281                         }
1282                 }
1283
1284                 cifs_fattr_to_inode(inode, fattr);
1285                 if (sb->s_flags & SB_NOATIME)
1286                         inode->i_flags |= S_NOATIME | S_NOCMTIME;
1287                 if (inode->i_state & I_NEW) {
1288                         inode->i_ino = hash;
1289 #ifdef CONFIG_CIFS_FSCACHE
1290                         /* initialize per-inode cache cookie pointer */
1291                         CIFS_I(inode)->fscache = NULL;
1292 #endif
1293                         unlock_new_inode(inode);
1294                 }
1295         }
1296
1297         return inode;
1298 }
1299
1300 /* gets root inode */
1301 struct inode *cifs_root_iget(struct super_block *sb)
1302 {
1303         unsigned int xid;
1304         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1305         struct inode *inode = NULL;
1306         long rc;
1307         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1308         char *path = NULL;
1309         int len;
1310
1311         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
1312             && cifs_sb->prepath) {
1313                 len = strlen(cifs_sb->prepath);
1314                 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
1315                 if (path == NULL)
1316                         return ERR_PTR(-ENOMEM);
1317                 path[0] = '/';
1318                 memcpy(path+1, cifs_sb->prepath, len);
1319         } else {
1320                 path = kstrdup("", GFP_KERNEL);
1321                 if (path == NULL)
1322                         return ERR_PTR(-ENOMEM);
1323         }
1324
1325         xid = get_xid();
1326         if (tcon->unix_ext) {
1327                 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1328                 /* some servers mistakenly claim POSIX support */
1329                 if (rc != -EOPNOTSUPP)
1330                         goto iget_no_retry;
1331                 cifs_dbg(VFS, "server does not support POSIX extensions\n");
1332                 tcon->unix_ext = false;
1333         }
1334
1335         convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1336         if (tcon->posix_extensions)
1337                 rc = smb311_posix_get_inode_info(&inode, path, sb, xid);
1338         else
1339                 rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1340
1341 iget_no_retry:
1342         if (!inode) {
1343                 inode = ERR_PTR(rc);
1344                 goto out;
1345         }
1346
1347 #ifdef CONFIG_CIFS_FSCACHE
1348         /* populate tcon->resource_id */
1349         tcon->resource_id = CIFS_I(inode)->uniqueid;
1350 #endif
1351
1352         if (rc && tcon->pipe) {
1353                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1354                 spin_lock(&inode->i_lock);
1355                 inode->i_mode |= S_IFDIR;
1356                 set_nlink(inode, 2);
1357                 inode->i_op = &cifs_ipc_inode_ops;
1358                 inode->i_fop = &simple_dir_operations;
1359                 inode->i_uid = cifs_sb->mnt_uid;
1360                 inode->i_gid = cifs_sb->mnt_gid;
1361                 spin_unlock(&inode->i_lock);
1362         } else if (rc) {
1363                 iget_failed(inode);
1364                 inode = ERR_PTR(rc);
1365         }
1366
1367 out:
1368         kfree(path);
1369         free_xid(xid);
1370         return inode;
1371 }
1372
1373 int
1374 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1375                    char *full_path, __u32 dosattr)
1376 {
1377         bool set_time = false;
1378         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1379         struct TCP_Server_Info *server;
1380         FILE_BASIC_INFO info_buf;
1381
1382         if (attrs == NULL)
1383                 return -EINVAL;
1384
1385         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1386         if (!server->ops->set_file_info)
1387                 return -ENOSYS;
1388
1389         info_buf.Pad = 0;
1390
1391         if (attrs->ia_valid & ATTR_ATIME) {
1392                 set_time = true;
1393                 info_buf.LastAccessTime =
1394                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1395         } else
1396                 info_buf.LastAccessTime = 0;
1397
1398         if (attrs->ia_valid & ATTR_MTIME) {
1399                 set_time = true;
1400                 info_buf.LastWriteTime =
1401                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1402         } else
1403                 info_buf.LastWriteTime = 0;
1404
1405         /*
1406          * Samba throws this field away, but windows may actually use it.
1407          * Do not set ctime unless other time stamps are changed explicitly
1408          * (i.e. by utimes()) since we would then have a mix of client and
1409          * server times.
1410          */
1411         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1412                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1413                 info_buf.ChangeTime =
1414                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1415         } else
1416                 info_buf.ChangeTime = 0;
1417
1418         info_buf.CreationTime = 0;      /* don't change */
1419         info_buf.Attributes = cpu_to_le32(dosattr);
1420
1421         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1422 }
1423
1424 /*
1425  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1426  * and rename it to a random name that hopefully won't conflict with
1427  * anything else.
1428  */
1429 int
1430 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1431                            const unsigned int xid)
1432 {
1433         int oplock = 0;
1434         int rc;
1435         struct cifs_fid fid;
1436         struct cifs_open_parms oparms;
1437         struct inode *inode = d_inode(dentry);
1438         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1439         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1440         struct tcon_link *tlink;
1441         struct cifs_tcon *tcon;
1442         __u32 dosattr, origattr;
1443         FILE_BASIC_INFO *info_buf = NULL;
1444
1445         tlink = cifs_sb_tlink(cifs_sb);
1446         if (IS_ERR(tlink))
1447                 return PTR_ERR(tlink);
1448         tcon = tlink_tcon(tlink);
1449
1450         /*
1451          * We cannot rename the file if the server doesn't support
1452          * CAP_INFOLEVEL_PASSTHRU
1453          */
1454         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1455                 rc = -EBUSY;
1456                 goto out;
1457         }
1458
1459         oparms.tcon = tcon;
1460         oparms.cifs_sb = cifs_sb;
1461         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1462         oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1463         oparms.disposition = FILE_OPEN;
1464         oparms.path = full_path;
1465         oparms.fid = &fid;
1466         oparms.reconnect = false;
1467
1468         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1469         if (rc != 0)
1470                 goto out;
1471
1472         origattr = cifsInode->cifsAttrs;
1473         if (origattr == 0)
1474                 origattr |= ATTR_NORMAL;
1475
1476         dosattr = origattr & ~ATTR_READONLY;
1477         if (dosattr == 0)
1478                 dosattr |= ATTR_NORMAL;
1479         dosattr |= ATTR_HIDDEN;
1480
1481         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1482         if (dosattr != origattr) {
1483                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1484                 if (info_buf == NULL) {
1485                         rc = -ENOMEM;
1486                         goto out_close;
1487                 }
1488                 info_buf->Attributes = cpu_to_le32(dosattr);
1489                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1490                                         current->tgid);
1491                 /* although we would like to mark the file hidden
1492                    if that fails we will still try to rename it */
1493                 if (!rc)
1494                         cifsInode->cifsAttrs = dosattr;
1495                 else
1496                         dosattr = origattr; /* since not able to change them */
1497         }
1498
1499         /* rename the file */
1500         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1501                                    cifs_sb->local_nls,
1502                                    cifs_remap(cifs_sb));
1503         if (rc != 0) {
1504                 rc = -EBUSY;
1505                 goto undo_setattr;
1506         }
1507
1508         /* try to set DELETE_ON_CLOSE */
1509         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1510                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1511                                                current->tgid);
1512                 /*
1513                  * some samba versions return -ENOENT when we try to set the
1514                  * file disposition here. Likely a samba bug, but work around
1515                  * it for now. This means that some cifsXXX files may hang
1516                  * around after they shouldn't.
1517                  *
1518                  * BB: remove this hack after more servers have the fix
1519                  */
1520                 if (rc == -ENOENT)
1521                         rc = 0;
1522                 else if (rc != 0) {
1523                         rc = -EBUSY;
1524                         goto undo_rename;
1525                 }
1526                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1527         }
1528
1529 out_close:
1530         CIFSSMBClose(xid, tcon, fid.netfid);
1531 out:
1532         kfree(info_buf);
1533         cifs_put_tlink(tlink);
1534         return rc;
1535
1536         /*
1537          * reset everything back to the original state. Don't bother
1538          * dealing with errors here since we can't do anything about
1539          * them anyway.
1540          */
1541 undo_rename:
1542         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1543                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1544 undo_setattr:
1545         if (dosattr != origattr) {
1546                 info_buf->Attributes = cpu_to_le32(origattr);
1547                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1548                                         current->tgid))
1549                         cifsInode->cifsAttrs = origattr;
1550         }
1551
1552         goto out_close;
1553 }
1554
1555 /* copied from fs/nfs/dir.c with small changes */
1556 static void
1557 cifs_drop_nlink(struct inode *inode)
1558 {
1559         spin_lock(&inode->i_lock);
1560         if (inode->i_nlink > 0)
1561                 drop_nlink(inode);
1562         spin_unlock(&inode->i_lock);
1563 }
1564
1565 /*
1566  * If d_inode(dentry) is null (usually meaning the cached dentry
1567  * is a negative dentry) then we would attempt a standard SMB delete, but
1568  * if that fails we can not attempt the fall back mechanisms on EACCES
1569  * but will return the EACCES to the caller. Note that the VFS does not call
1570  * unlink on negative dentries currently.
1571  */
1572 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1573 {
1574         int rc = 0;
1575         unsigned int xid;
1576         char *full_path = NULL;
1577         struct inode *inode = d_inode(dentry);
1578         struct cifsInodeInfo *cifs_inode;
1579         struct super_block *sb = dir->i_sb;
1580         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1581         struct tcon_link *tlink;
1582         struct cifs_tcon *tcon;
1583         struct TCP_Server_Info *server;
1584         struct iattr *attrs = NULL;
1585         __u32 dosattr = 0, origattr = 0;
1586
1587         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1588
1589         tlink = cifs_sb_tlink(cifs_sb);
1590         if (IS_ERR(tlink))
1591                 return PTR_ERR(tlink);
1592         tcon = tlink_tcon(tlink);
1593         server = tcon->ses->server;
1594
1595         xid = get_xid();
1596
1597         if (tcon->nodelete) {
1598                 rc = -EACCES;
1599                 goto unlink_out;
1600         }
1601
1602         /* Unlink can be called from rename so we can not take the
1603          * sb->s_vfs_rename_mutex here */
1604         full_path = build_path_from_dentry(dentry);
1605         if (full_path == NULL) {
1606                 rc = -ENOMEM;
1607                 goto unlink_out;
1608         }
1609
1610         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1611                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1612                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1613                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1614                         cifs_remap(cifs_sb));
1615                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1616                 if ((rc == 0) || (rc == -ENOENT))
1617                         goto psx_del_no_retry;
1618         }
1619
1620 retry_std_delete:
1621         if (!server->ops->unlink) {
1622                 rc = -ENOSYS;
1623                 goto psx_del_no_retry;
1624         }
1625
1626         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1627
1628 psx_del_no_retry:
1629         if (!rc) {
1630                 if (inode)
1631                         cifs_drop_nlink(inode);
1632         } else if (rc == -ENOENT) {
1633                 d_drop(dentry);
1634         } else if (rc == -EBUSY) {
1635                 if (server->ops->rename_pending_delete) {
1636                         rc = server->ops->rename_pending_delete(full_path,
1637                                                                 dentry, xid);
1638                         if (rc == 0)
1639                                 cifs_drop_nlink(inode);
1640                 }
1641         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1642                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1643                 if (attrs == NULL) {
1644                         rc = -ENOMEM;
1645                         goto out_reval;
1646                 }
1647
1648                 /* try to reset dos attributes */
1649                 cifs_inode = CIFS_I(inode);
1650                 origattr = cifs_inode->cifsAttrs;
1651                 if (origattr == 0)
1652                         origattr |= ATTR_NORMAL;
1653                 dosattr = origattr & ~ATTR_READONLY;
1654                 if (dosattr == 0)
1655                         dosattr |= ATTR_NORMAL;
1656                 dosattr |= ATTR_HIDDEN;
1657
1658                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1659                 if (rc != 0)
1660                         goto out_reval;
1661
1662                 goto retry_std_delete;
1663         }
1664
1665         /* undo the setattr if we errored out and it's needed */
1666         if (rc != 0 && dosattr != 0)
1667                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1668
1669 out_reval:
1670         if (inode) {
1671                 cifs_inode = CIFS_I(inode);
1672                 cifs_inode->time = 0;   /* will force revalidate to get info
1673                                            when needed */
1674                 inode->i_ctime = current_time(inode);
1675         }
1676         dir->i_ctime = dir->i_mtime = current_time(dir);
1677         cifs_inode = CIFS_I(dir);
1678         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1679 unlink_out:
1680         kfree(full_path);
1681         kfree(attrs);
1682         free_xid(xid);
1683         cifs_put_tlink(tlink);
1684         return rc;
1685 }
1686
1687 static int
1688 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1689                  const char *full_path, struct cifs_sb_info *cifs_sb,
1690                  struct cifs_tcon *tcon, const unsigned int xid)
1691 {
1692         int rc = 0;
1693         struct inode *inode = NULL;
1694
1695         if (tcon->posix_extensions)
1696                 rc = smb311_posix_get_inode_info(&inode, full_path, parent->i_sb, xid);
1697         else if (tcon->unix_ext)
1698                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1699                                               xid);
1700         else
1701                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1702                                          xid, NULL);
1703
1704         if (rc)
1705                 return rc;
1706
1707         /*
1708          * setting nlink not necessary except in cases where we failed to get it
1709          * from the server or was set bogus. Also, since this is a brand new
1710          * inode, no need to grab the i_lock before setting the i_nlink.
1711          */
1712         if (inode->i_nlink < 2)
1713                 set_nlink(inode, 2);
1714         mode &= ~current_umask();
1715         /* must turn on setgid bit if parent dir has it */
1716         if (parent->i_mode & S_ISGID)
1717                 mode |= S_ISGID;
1718
1719         if (tcon->unix_ext) {
1720                 struct cifs_unix_set_info_args args = {
1721                         .mode   = mode,
1722                         .ctime  = NO_CHANGE_64,
1723                         .atime  = NO_CHANGE_64,
1724                         .mtime  = NO_CHANGE_64,
1725                         .device = 0,
1726                 };
1727                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1728                         args.uid = current_fsuid();
1729                         if (parent->i_mode & S_ISGID)
1730                                 args.gid = parent->i_gid;
1731                         else
1732                                 args.gid = current_fsgid();
1733                 } else {
1734                         args.uid = INVALID_UID; /* no change */
1735                         args.gid = INVALID_GID; /* no change */
1736                 }
1737                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1738                                        cifs_sb->local_nls,
1739                                        cifs_remap(cifs_sb));
1740         } else {
1741                 struct TCP_Server_Info *server = tcon->ses->server;
1742                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1743                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1744                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1745                                                    tcon, xid);
1746                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1747                         inode->i_mode = (mode | S_IFDIR);
1748
1749                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1750                         inode->i_uid = current_fsuid();
1751                         if (inode->i_mode & S_ISGID)
1752                                 inode->i_gid = parent->i_gid;
1753                         else
1754                                 inode->i_gid = current_fsgid();
1755                 }
1756         }
1757         d_instantiate(dentry, inode);
1758         return rc;
1759 }
1760
1761 static int
1762 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1763                  const char *full_path, struct cifs_sb_info *cifs_sb,
1764                  struct cifs_tcon *tcon, const unsigned int xid)
1765 {
1766         int rc = 0;
1767         u32 oplock = 0;
1768         FILE_UNIX_BASIC_INFO *info = NULL;
1769         struct inode *newinode = NULL;
1770         struct cifs_fattr fattr;
1771
1772         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1773         if (info == NULL) {
1774                 rc = -ENOMEM;
1775                 goto posix_mkdir_out;
1776         }
1777
1778         mode &= ~current_umask();
1779         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1780                              NULL /* netfid */, info, &oplock, full_path,
1781                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1782         if (rc == -EOPNOTSUPP)
1783                 goto posix_mkdir_out;
1784         else if (rc) {
1785                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1786                 d_drop(dentry);
1787                 goto posix_mkdir_out;
1788         }
1789
1790         if (info->Type == cpu_to_le32(-1))
1791                 /* no return info, go query for it */
1792                 goto posix_mkdir_get_info;
1793         /*
1794          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1795          * need to set uid/gid.
1796          */
1797
1798         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1799         cifs_fill_uniqueid(inode->i_sb, &fattr);
1800         newinode = cifs_iget(inode->i_sb, &fattr);
1801         if (!newinode)
1802                 goto posix_mkdir_get_info;
1803
1804         d_instantiate(dentry, newinode);
1805
1806 #ifdef CONFIG_CIFS_DEBUG2
1807         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1808                  dentry, dentry, newinode);
1809
1810         if (newinode->i_nlink != 2)
1811                 cifs_dbg(FYI, "unexpected number of links %d\n",
1812                          newinode->i_nlink);
1813 #endif
1814
1815 posix_mkdir_out:
1816         kfree(info);
1817         return rc;
1818 posix_mkdir_get_info:
1819         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1820                               xid);
1821         goto posix_mkdir_out;
1822 }
1823
1824 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1825 {
1826         int rc = 0;
1827         unsigned int xid;
1828         struct cifs_sb_info *cifs_sb;
1829         struct tcon_link *tlink;
1830         struct cifs_tcon *tcon;
1831         struct TCP_Server_Info *server;
1832         char *full_path;
1833
1834         cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1835                  mode, inode);
1836
1837         cifs_sb = CIFS_SB(inode->i_sb);
1838         tlink = cifs_sb_tlink(cifs_sb);
1839         if (IS_ERR(tlink))
1840                 return PTR_ERR(tlink);
1841         tcon = tlink_tcon(tlink);
1842
1843         xid = get_xid();
1844
1845         full_path = build_path_from_dentry(direntry);
1846         if (full_path == NULL) {
1847                 rc = -ENOMEM;
1848                 goto mkdir_out;
1849         }
1850
1851         server = tcon->ses->server;
1852
1853         if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1854                 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1855                                               cifs_sb);
1856                 d_drop(direntry); /* for time being always refresh inode info */
1857                 goto mkdir_out;
1858         }
1859
1860         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1861                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1862                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1863                                       tcon, xid);
1864                 if (rc != -EOPNOTSUPP)
1865                         goto mkdir_out;
1866         }
1867
1868         if (!server->ops->mkdir) {
1869                 rc = -ENOSYS;
1870                 goto mkdir_out;
1871         }
1872
1873         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1874         rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1875         if (rc) {
1876                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1877                 d_drop(direntry);
1878                 goto mkdir_out;
1879         }
1880
1881         /* TODO: skip this for smb2/smb3 */
1882         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1883                               xid);
1884 mkdir_out:
1885         /*
1886          * Force revalidate to get parent dir info when needed since cached
1887          * attributes are invalid now.
1888          */
1889         CIFS_I(inode)->time = 0;
1890         kfree(full_path);
1891         free_xid(xid);
1892         cifs_put_tlink(tlink);
1893         return rc;
1894 }
1895
1896 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1897 {
1898         int rc = 0;
1899         unsigned int xid;
1900         struct cifs_sb_info *cifs_sb;
1901         struct tcon_link *tlink;
1902         struct cifs_tcon *tcon;
1903         struct TCP_Server_Info *server;
1904         char *full_path = NULL;
1905         struct cifsInodeInfo *cifsInode;
1906
1907         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1908
1909         xid = get_xid();
1910
1911         full_path = build_path_from_dentry(direntry);
1912         if (full_path == NULL) {
1913                 rc = -ENOMEM;
1914                 goto rmdir_exit;
1915         }
1916
1917         cifs_sb = CIFS_SB(inode->i_sb);
1918         tlink = cifs_sb_tlink(cifs_sb);
1919         if (IS_ERR(tlink)) {
1920                 rc = PTR_ERR(tlink);
1921                 goto rmdir_exit;
1922         }
1923         tcon = tlink_tcon(tlink);
1924         server = tcon->ses->server;
1925
1926         if (!server->ops->rmdir) {
1927                 rc = -ENOSYS;
1928                 cifs_put_tlink(tlink);
1929                 goto rmdir_exit;
1930         }
1931
1932         if (tcon->nodelete) {
1933                 rc = -EACCES;
1934                 cifs_put_tlink(tlink);
1935                 goto rmdir_exit;
1936         }
1937
1938         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1939         cifs_put_tlink(tlink);
1940
1941         if (!rc) {
1942                 spin_lock(&d_inode(direntry)->i_lock);
1943                 i_size_write(d_inode(direntry), 0);
1944                 clear_nlink(d_inode(direntry));
1945                 spin_unlock(&d_inode(direntry)->i_lock);
1946         }
1947
1948         cifsInode = CIFS_I(d_inode(direntry));
1949         /* force revalidate to go get info when needed */
1950         cifsInode->time = 0;
1951
1952         cifsInode = CIFS_I(inode);
1953         /*
1954          * Force revalidate to get parent dir info when needed since cached
1955          * attributes are invalid now.
1956          */
1957         cifsInode->time = 0;
1958
1959         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1960                 current_time(inode);
1961
1962 rmdir_exit:
1963         kfree(full_path);
1964         free_xid(xid);
1965         return rc;
1966 }
1967
1968 static int
1969 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1970                const char *from_path, struct dentry *to_dentry,
1971                const char *to_path)
1972 {
1973         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1974         struct tcon_link *tlink;
1975         struct cifs_tcon *tcon;
1976         struct TCP_Server_Info *server;
1977         struct cifs_fid fid;
1978         struct cifs_open_parms oparms;
1979         int oplock, rc;
1980
1981         tlink = cifs_sb_tlink(cifs_sb);
1982         if (IS_ERR(tlink))
1983                 return PTR_ERR(tlink);
1984         tcon = tlink_tcon(tlink);
1985         server = tcon->ses->server;
1986
1987         if (!server->ops->rename)
1988                 return -ENOSYS;
1989
1990         /* try path-based rename first */
1991         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1992
1993         /*
1994          * Don't bother with rename by filehandle unless file is busy and
1995          * source. Note that cross directory moves do not work with
1996          * rename by filehandle to various Windows servers.
1997          */
1998         if (rc == 0 || rc != -EBUSY)
1999                 goto do_rename_exit;
2000
2001         /* Don't fall back to using SMB on SMB 2+ mount */
2002         if (server->vals->protocol_id != 0)
2003                 goto do_rename_exit;
2004
2005         /* open-file renames don't work across directories */
2006         if (to_dentry->d_parent != from_dentry->d_parent)
2007                 goto do_rename_exit;
2008
2009         oparms.tcon = tcon;
2010         oparms.cifs_sb = cifs_sb;
2011         /* open the file to be renamed -- we need DELETE perms */
2012         oparms.desired_access = DELETE;
2013         oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2014         oparms.disposition = FILE_OPEN;
2015         oparms.path = from_path;
2016         oparms.fid = &fid;
2017         oparms.reconnect = false;
2018
2019         rc = CIFS_open(xid, &oparms, &oplock, NULL);
2020         if (rc == 0) {
2021                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2022                                 (const char *) to_dentry->d_name.name,
2023                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
2024                 CIFSSMBClose(xid, tcon, fid.netfid);
2025         }
2026 do_rename_exit:
2027         if (rc == 0)
2028                 d_move(from_dentry, to_dentry);
2029         cifs_put_tlink(tlink);
2030         return rc;
2031 }
2032
2033 int
2034 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
2035              struct inode *target_dir, struct dentry *target_dentry,
2036              unsigned int flags)
2037 {
2038         char *from_name = NULL;
2039         char *to_name = NULL;
2040         struct cifs_sb_info *cifs_sb;
2041         struct tcon_link *tlink;
2042         struct cifs_tcon *tcon;
2043         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2044         FILE_UNIX_BASIC_INFO *info_buf_target;
2045         unsigned int xid;
2046         int rc, tmprc;
2047         bool new_target = d_really_is_negative(target_dentry);
2048
2049         if (flags & ~RENAME_NOREPLACE)
2050                 return -EINVAL;
2051
2052         cifs_sb = CIFS_SB(source_dir->i_sb);
2053         tlink = cifs_sb_tlink(cifs_sb);
2054         if (IS_ERR(tlink))
2055                 return PTR_ERR(tlink);
2056         tcon = tlink_tcon(tlink);
2057
2058         xid = get_xid();
2059
2060         /*
2061          * we already have the rename sem so we do not need to
2062          * grab it again here to protect the path integrity
2063          */
2064         from_name = build_path_from_dentry(source_dentry);
2065         if (from_name == NULL) {
2066                 rc = -ENOMEM;
2067                 goto cifs_rename_exit;
2068         }
2069
2070         to_name = build_path_from_dentry(target_dentry);
2071         if (to_name == NULL) {
2072                 rc = -ENOMEM;
2073                 goto cifs_rename_exit;
2074         }
2075
2076         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2077                             to_name);
2078
2079         /*
2080          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2081          */
2082         if (flags & RENAME_NOREPLACE)
2083                 goto cifs_rename_exit;
2084
2085         if (rc == -EEXIST && tcon->unix_ext) {
2086                 /*
2087                  * Are src and dst hardlinks of same inode? We can only tell
2088                  * with unix extensions enabled.
2089                  */
2090                 info_buf_source =
2091                         kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2092                                         GFP_KERNEL);
2093                 if (info_buf_source == NULL) {
2094                         rc = -ENOMEM;
2095                         goto cifs_rename_exit;
2096                 }
2097
2098                 info_buf_target = info_buf_source + 1;
2099                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2100                                              info_buf_source,
2101                                              cifs_sb->local_nls,
2102                                              cifs_remap(cifs_sb));
2103                 if (tmprc != 0)
2104                         goto unlink_target;
2105
2106                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2107                                              info_buf_target,
2108                                              cifs_sb->local_nls,
2109                                              cifs_remap(cifs_sb));
2110
2111                 if (tmprc == 0 && (info_buf_source->UniqueId ==
2112                                    info_buf_target->UniqueId)) {
2113                         /* same file, POSIX says that this is a noop */
2114                         rc = 0;
2115                         goto cifs_rename_exit;
2116                 }
2117         }
2118         /*
2119          * else ... BB we could add the same check for Windows by
2120          * checking the UniqueId via FILE_INTERNAL_INFO
2121          */
2122
2123 unlink_target:
2124         /*
2125          * If the target dentry was created during the rename, try
2126          * unlinking it if it's not negative
2127          */
2128         if (new_target &&
2129             d_really_is_positive(target_dentry) &&
2130             (rc == -EACCES || rc == -EEXIST)) {
2131                 if (d_is_dir(target_dentry))
2132                         tmprc = cifs_rmdir(target_dir, target_dentry);
2133                 else
2134                         tmprc = cifs_unlink(target_dir, target_dentry);
2135                 if (tmprc)
2136                         goto cifs_rename_exit;
2137                 rc = cifs_do_rename(xid, source_dentry, from_name,
2138                                     target_dentry, to_name);
2139         }
2140
2141         /* force revalidate to go get info when needed */
2142         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2143
2144         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2145                 target_dir->i_mtime = current_time(source_dir);
2146
2147 cifs_rename_exit:
2148         kfree(info_buf_source);
2149         kfree(from_name);
2150         kfree(to_name);
2151         free_xid(xid);
2152         cifs_put_tlink(tlink);
2153         return rc;
2154 }
2155
2156 static bool
2157 cifs_inode_needs_reval(struct inode *inode)
2158 {
2159         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2160         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2161
2162         if (cifs_i->time == 0)
2163                 return true;
2164
2165         if (CIFS_CACHE_READ(cifs_i))
2166                 return false;
2167
2168         if (!lookupCacheEnabled)
2169                 return true;
2170
2171         if (!cifs_sb->actimeo)
2172                 return true;
2173
2174         if (!time_in_range(jiffies, cifs_i->time,
2175                                 cifs_i->time + cifs_sb->actimeo))
2176                 return true;
2177
2178         /* hardlinked files w/ noserverino get "special" treatment */
2179         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2180             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2181                 return true;
2182
2183         return false;
2184 }
2185
2186 /*
2187  * Zap the cache. Called when invalid_mapping flag is set.
2188  */
2189 int
2190 cifs_invalidate_mapping(struct inode *inode)
2191 {
2192         int rc = 0;
2193
2194         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2195                 rc = invalidate_inode_pages2(inode->i_mapping);
2196                 if (rc)
2197                         cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2198                                  __func__, inode);
2199         }
2200
2201         cifs_fscache_reset_inode_cookie(inode);
2202         return rc;
2203 }
2204
2205 /**
2206  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2207  * @word: long word containing the bit lock
2208  */
2209 static int
2210 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2211 {
2212         freezable_schedule_unsafe();
2213         if (signal_pending_state(mode, current))
2214                 return -ERESTARTSYS;
2215         return 0;
2216 }
2217
2218 int
2219 cifs_revalidate_mapping(struct inode *inode)
2220 {
2221         int rc;
2222         unsigned long *flags = &CIFS_I(inode)->flags;
2223
2224         /* swapfiles are not supposed to be shared */
2225         if (IS_SWAPFILE(inode))
2226                 return 0;
2227
2228         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2229                                      TASK_KILLABLE);
2230         if (rc)
2231                 return rc;
2232
2233         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2234                 rc = cifs_invalidate_mapping(inode);
2235                 if (rc)
2236                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
2237         }
2238
2239         clear_bit_unlock(CIFS_INO_LOCK, flags);
2240         smp_mb__after_atomic();
2241         wake_up_bit(flags, CIFS_INO_LOCK);
2242
2243         return rc;
2244 }
2245
2246 int
2247 cifs_zap_mapping(struct inode *inode)
2248 {
2249         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2250         return cifs_revalidate_mapping(inode);
2251 }
2252
2253 int cifs_revalidate_file_attr(struct file *filp)
2254 {
2255         int rc = 0;
2256         struct inode *inode = file_inode(filp);
2257         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2258
2259         if (!cifs_inode_needs_reval(inode))
2260                 return rc;
2261
2262         if (tlink_tcon(cfile->tlink)->unix_ext)
2263                 rc = cifs_get_file_info_unix(filp);
2264         else
2265                 rc = cifs_get_file_info(filp);
2266
2267         return rc;
2268 }
2269
2270 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2271 {
2272         unsigned int xid;
2273         int rc = 0;
2274         struct inode *inode = d_inode(dentry);
2275         struct super_block *sb = dentry->d_sb;
2276         char *full_path = NULL;
2277         int count = 0;
2278
2279         if (inode == NULL)
2280                 return -ENOENT;
2281
2282         if (!cifs_inode_needs_reval(inode))
2283                 return rc;
2284
2285         xid = get_xid();
2286
2287         /* can not safely grab the rename sem here if rename calls revalidate
2288            since that would deadlock */
2289         full_path = build_path_from_dentry(dentry);
2290         if (full_path == NULL) {
2291                 rc = -ENOMEM;
2292                 goto out;
2293         }
2294
2295         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2296                  full_path, inode, inode->i_count.counter,
2297                  dentry, cifs_get_time(dentry), jiffies);
2298
2299 again:
2300         if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2301                 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2302         else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2303                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2304         else
2305                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2306                                          xid, NULL);
2307         if (rc == -EAGAIN && count++ < 10)
2308                 goto again;
2309 out:
2310         kfree(full_path);
2311         free_xid(xid);
2312
2313         return rc;
2314 }
2315
2316 int cifs_revalidate_file(struct file *filp)
2317 {
2318         int rc;
2319         struct inode *inode = file_inode(filp);
2320
2321         rc = cifs_revalidate_file_attr(filp);
2322         if (rc)
2323                 return rc;
2324
2325         return cifs_revalidate_mapping(inode);
2326 }
2327
2328 /* revalidate a dentry's inode attributes */
2329 int cifs_revalidate_dentry(struct dentry *dentry)
2330 {
2331         int rc;
2332         struct inode *inode = d_inode(dentry);
2333
2334         rc = cifs_revalidate_dentry_attr(dentry);
2335         if (rc)
2336                 return rc;
2337
2338         return cifs_revalidate_mapping(inode);
2339 }
2340
2341 int cifs_getattr(const struct path *path, struct kstat *stat,
2342                  u32 request_mask, unsigned int flags)
2343 {
2344         struct dentry *dentry = path->dentry;
2345         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2346         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2347         struct inode *inode = d_inode(dentry);
2348         int rc;
2349
2350         /*
2351          * We need to be sure that all dirty pages are written and the server
2352          * has actual ctime, mtime and file length.
2353          */
2354         if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
2355             !CIFS_CACHE_READ(CIFS_I(inode)) &&
2356             inode->i_mapping && inode->i_mapping->nrpages != 0) {
2357                 rc = filemap_fdatawait(inode->i_mapping);
2358                 if (rc) {
2359                         mapping_set_error(inode->i_mapping, rc);
2360                         return rc;
2361                 }
2362         }
2363
2364         if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2365                 CIFS_I(inode)->time = 0; /* force revalidate */
2366
2367         /*
2368          * If the caller doesn't require syncing, only sync if
2369          * necessary (e.g. due to earlier truncate or setattr
2370          * invalidating the cached metadata)
2371          */
2372         if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2373             (CIFS_I(inode)->time == 0)) {
2374                 rc = cifs_revalidate_dentry_attr(dentry);
2375                 if (rc)
2376                         return rc;
2377         }
2378
2379         generic_fillattr(inode, stat);
2380         stat->blksize = cifs_sb->bsize;
2381         stat->ino = CIFS_I(inode)->uniqueid;
2382
2383         /* old CIFS Unix Extensions doesn't return create time */
2384         if (CIFS_I(inode)->createtime) {
2385                 stat->result_mask |= STATX_BTIME;
2386                 stat->btime =
2387                       cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2388         }
2389
2390         stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2391         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2392                 stat->attributes |= STATX_ATTR_COMPRESSED;
2393         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2394                 stat->attributes |= STATX_ATTR_ENCRYPTED;
2395
2396         /*
2397          * If on a multiuser mount without unix extensions or cifsacl being
2398          * enabled, and the admin hasn't overridden them, set the ownership
2399          * to the fsuid/fsgid of the current process.
2400          */
2401         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2402             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2403             !tcon->unix_ext) {
2404                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2405                         stat->uid = current_fsuid();
2406                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2407                         stat->gid = current_fsgid();
2408         }
2409         return 0;
2410 }
2411
2412 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2413                 u64 len)
2414 {
2415         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2416         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2417         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2418         struct TCP_Server_Info *server = tcon->ses->server;
2419         struct cifsFileInfo *cfile;
2420         int rc;
2421
2422         /*
2423          * We need to be sure that all dirty pages are written as they
2424          * might fill holes on the server.
2425          */
2426         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2427             inode->i_mapping->nrpages != 0) {
2428                 rc = filemap_fdatawait(inode->i_mapping);
2429                 if (rc) {
2430                         mapping_set_error(inode->i_mapping, rc);
2431                         return rc;
2432                 }
2433         }
2434
2435         cfile = find_readable_file(cifs_i, false);
2436         if (cfile == NULL)
2437                 return -EINVAL;
2438
2439         if (server->ops->fiemap) {
2440                 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2441                 cifsFileInfo_put(cfile);
2442                 return rc;
2443         }
2444
2445         cifsFileInfo_put(cfile);
2446         return -ENOTSUPP;
2447 }
2448
2449 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2450 {
2451         pgoff_t index = from >> PAGE_SHIFT;
2452         unsigned offset = from & (PAGE_SIZE - 1);
2453         struct page *page;
2454         int rc = 0;
2455
2456         page = grab_cache_page(mapping, index);
2457         if (!page)
2458                 return -ENOMEM;
2459
2460         zero_user_segment(page, offset, PAGE_SIZE);
2461         unlock_page(page);
2462         put_page(page);
2463         return rc;
2464 }
2465
2466 void cifs_setsize(struct inode *inode, loff_t offset)
2467 {
2468         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2469
2470         spin_lock(&inode->i_lock);
2471         i_size_write(inode, offset);
2472         spin_unlock(&inode->i_lock);
2473
2474         /* Cached inode must be refreshed on truncate */
2475         cifs_i->time = 0;
2476         truncate_pagecache(inode, offset);
2477 }
2478
2479 static int
2480 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2481                    unsigned int xid, char *full_path)
2482 {
2483         int rc;
2484         struct cifsFileInfo *open_file;
2485         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2486         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2487         struct tcon_link *tlink = NULL;
2488         struct cifs_tcon *tcon = NULL;
2489         struct TCP_Server_Info *server;
2490
2491         /*
2492          * To avoid spurious oplock breaks from server, in the case of
2493          * inodes that we already have open, avoid doing path based
2494          * setting of file size if we can do it by handle.
2495          * This keeps our caching token (oplock) and avoids timeouts
2496          * when the local oplock break takes longer to flush
2497          * writebehind data than the SMB timeout for the SetPathInfo
2498          * request would allow
2499          */
2500         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2501         if (open_file) {
2502                 tcon = tlink_tcon(open_file->tlink);
2503                 server = tcon->ses->server;
2504                 if (server->ops->set_file_size)
2505                         rc = server->ops->set_file_size(xid, tcon, open_file,
2506                                                         attrs->ia_size, false);
2507                 else
2508                         rc = -ENOSYS;
2509                 cifsFileInfo_put(open_file);
2510                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2511         } else
2512                 rc = -EINVAL;
2513
2514         if (!rc)
2515                 goto set_size_out;
2516
2517         if (tcon == NULL) {
2518                 tlink = cifs_sb_tlink(cifs_sb);
2519                 if (IS_ERR(tlink))
2520                         return PTR_ERR(tlink);
2521                 tcon = tlink_tcon(tlink);
2522                 server = tcon->ses->server;
2523         }
2524
2525         /*
2526          * Set file size by pathname rather than by handle either because no
2527          * valid, writeable file handle for it was found or because there was
2528          * an error setting it by handle.
2529          */
2530         if (server->ops->set_path_size)
2531                 rc = server->ops->set_path_size(xid, tcon, full_path,
2532                                                 attrs->ia_size, cifs_sb, false);
2533         else
2534                 rc = -ENOSYS;
2535         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2536
2537         if (tlink)
2538                 cifs_put_tlink(tlink);
2539
2540 set_size_out:
2541         if (rc == 0) {
2542                 cifsInode->server_eof = attrs->ia_size;
2543                 cifs_setsize(inode, attrs->ia_size);
2544
2545                 /*
2546                  * The man page of truncate says if the size changed,
2547                  * then the st_ctime and st_mtime fields for the file
2548                  * are updated.
2549                  */
2550                 attrs->ia_ctime = attrs->ia_mtime = current_time(inode);
2551                 attrs->ia_valid |= ATTR_CTIME | ATTR_MTIME;
2552
2553                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2554         }
2555
2556         return rc;
2557 }
2558
2559 static int
2560 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2561 {
2562         int rc;
2563         unsigned int xid;
2564         char *full_path = NULL;
2565         struct inode *inode = d_inode(direntry);
2566         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2567         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2568         struct tcon_link *tlink;
2569         struct cifs_tcon *pTcon;
2570         struct cifs_unix_set_info_args *args = NULL;
2571         struct cifsFileInfo *open_file;
2572
2573         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2574                  direntry, attrs->ia_valid);
2575
2576         xid = get_xid();
2577
2578         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2579                 attrs->ia_valid |= ATTR_FORCE;
2580
2581         rc = setattr_prepare(direntry, attrs);
2582         if (rc < 0)
2583                 goto out;
2584
2585         full_path = build_path_from_dentry(direntry);
2586         if (full_path == NULL) {
2587                 rc = -ENOMEM;
2588                 goto out;
2589         }
2590
2591         /*
2592          * Attempt to flush data before changing attributes. We need to do
2593          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2594          * ownership or mode then we may also need to do this. Here, we take
2595          * the safe way out and just do the flush on all setattr requests. If
2596          * the flush returns error, store it to report later and continue.
2597          *
2598          * BB: This should be smarter. Why bother flushing pages that
2599          * will be truncated anyway? Also, should we error out here if
2600          * the flush returns error?
2601          */
2602         rc = filemap_write_and_wait(inode->i_mapping);
2603         if (is_interrupt_error(rc)) {
2604                 rc = -ERESTARTSYS;
2605                 goto out;
2606         }
2607
2608         mapping_set_error(inode->i_mapping, rc);
2609         rc = 0;
2610
2611         if (attrs->ia_valid & ATTR_SIZE) {
2612                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2613                 if (rc != 0)
2614                         goto out;
2615         }
2616
2617         /* skip mode change if it's just for clearing setuid/setgid */
2618         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2619                 attrs->ia_valid &= ~ATTR_MODE;
2620
2621         args = kmalloc(sizeof(*args), GFP_KERNEL);
2622         if (args == NULL) {
2623                 rc = -ENOMEM;
2624                 goto out;
2625         }
2626
2627         /* set up the struct */
2628         if (attrs->ia_valid & ATTR_MODE)
2629                 args->mode = attrs->ia_mode;
2630         else
2631                 args->mode = NO_CHANGE_64;
2632
2633         if (attrs->ia_valid & ATTR_UID)
2634                 args->uid = attrs->ia_uid;
2635         else
2636                 args->uid = INVALID_UID; /* no change */
2637
2638         if (attrs->ia_valid & ATTR_GID)
2639                 args->gid = attrs->ia_gid;
2640         else
2641                 args->gid = INVALID_GID; /* no change */
2642
2643         if (attrs->ia_valid & ATTR_ATIME)
2644                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2645         else
2646                 args->atime = NO_CHANGE_64;
2647
2648         if (attrs->ia_valid & ATTR_MTIME)
2649                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2650         else
2651                 args->mtime = NO_CHANGE_64;
2652
2653         if (attrs->ia_valid & ATTR_CTIME)
2654                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2655         else
2656                 args->ctime = NO_CHANGE_64;
2657
2658         args->device = 0;
2659         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2660         if (open_file) {
2661                 u16 nfid = open_file->fid.netfid;
2662                 u32 npid = open_file->pid;
2663                 pTcon = tlink_tcon(open_file->tlink);
2664                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2665                 cifsFileInfo_put(open_file);
2666         } else {
2667                 tlink = cifs_sb_tlink(cifs_sb);
2668                 if (IS_ERR(tlink)) {
2669                         rc = PTR_ERR(tlink);
2670                         goto out;
2671                 }
2672                 pTcon = tlink_tcon(tlink);
2673                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2674                                     cifs_sb->local_nls,
2675                                     cifs_remap(cifs_sb));
2676                 cifs_put_tlink(tlink);
2677         }
2678
2679         if (rc)
2680                 goto out;
2681
2682         if ((attrs->ia_valid & ATTR_SIZE) &&
2683             attrs->ia_size != i_size_read(inode))
2684                 truncate_setsize(inode, attrs->ia_size);
2685
2686         setattr_copy(inode, attrs);
2687         mark_inode_dirty(inode);
2688
2689         /* force revalidate when any of these times are set since some
2690            of the fs types (eg ext3, fat) do not have fine enough
2691            time granularity to match protocol, and we do not have a
2692            a way (yet) to query the server fs's time granularity (and
2693            whether it rounds times down).
2694         */
2695         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2696                 cifsInode->time = 0;
2697 out:
2698         kfree(args);
2699         kfree(full_path);
2700         free_xid(xid);
2701         return rc;
2702 }
2703
2704 static int
2705 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2706 {
2707         unsigned int xid;
2708         kuid_t uid = INVALID_UID;
2709         kgid_t gid = INVALID_GID;
2710         struct inode *inode = d_inode(direntry);
2711         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2712         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2713         struct cifsFileInfo *wfile;
2714         struct cifs_tcon *tcon;
2715         char *full_path = NULL;
2716         int rc = -EACCES;
2717         __u32 dosattr = 0;
2718         __u64 mode = NO_CHANGE_64;
2719
2720         xid = get_xid();
2721
2722         cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2723                  direntry, attrs->ia_valid);
2724
2725         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2726                 attrs->ia_valid |= ATTR_FORCE;
2727
2728         rc = setattr_prepare(direntry, attrs);
2729         if (rc < 0) {
2730                 free_xid(xid);
2731                 return rc;
2732         }
2733
2734         full_path = build_path_from_dentry(direntry);
2735         if (full_path == NULL) {
2736                 rc = -ENOMEM;
2737                 free_xid(xid);
2738                 return rc;
2739         }
2740
2741         /*
2742          * Attempt to flush data before changing attributes. We need to do
2743          * this for ATTR_SIZE and ATTR_MTIME.  If the flush of the data
2744          * returns error, store it to report later and continue.
2745          *
2746          * BB: This should be smarter. Why bother flushing pages that
2747          * will be truncated anyway? Also, should we error out here if
2748          * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2749          */
2750         if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2751                 rc = filemap_write_and_wait(inode->i_mapping);
2752                 if (is_interrupt_error(rc)) {
2753                         rc = -ERESTARTSYS;
2754                         goto cifs_setattr_exit;
2755                 }
2756                 mapping_set_error(inode->i_mapping, rc);
2757         }
2758
2759         rc = 0;
2760
2761         if ((attrs->ia_valid & ATTR_MTIME) &&
2762             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2763                 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2764                 if (!rc) {
2765                         tcon = tlink_tcon(wfile->tlink);
2766                         rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2767                         cifsFileInfo_put(wfile);
2768                         if (rc)
2769                                 goto cifs_setattr_exit;
2770                 } else if (rc != -EBADF)
2771                         goto cifs_setattr_exit;
2772                 else
2773                         rc = 0;
2774         }
2775
2776         if (attrs->ia_valid & ATTR_SIZE) {
2777                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2778                 if (rc != 0)
2779                         goto cifs_setattr_exit;
2780         }
2781
2782         if (attrs->ia_valid & ATTR_UID)
2783                 uid = attrs->ia_uid;
2784
2785         if (attrs->ia_valid & ATTR_GID)
2786                 gid = attrs->ia_gid;
2787
2788         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2789             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2790                 if (uid_valid(uid) || gid_valid(gid)) {
2791                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2792                                                         uid, gid);
2793                         if (rc) {
2794                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2795                                          __func__, rc);
2796                                 goto cifs_setattr_exit;
2797                         }
2798                 }
2799         } else
2800         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2801                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2802
2803         /* skip mode change if it's just for clearing setuid/setgid */
2804         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2805                 attrs->ia_valid &= ~ATTR_MODE;
2806
2807         if (attrs->ia_valid & ATTR_MODE) {
2808                 mode = attrs->ia_mode;
2809                 rc = 0;
2810                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2811                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2812                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2813                                                 INVALID_UID, INVALID_GID);
2814                         if (rc) {
2815                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2816                                          __func__, rc);
2817                                 goto cifs_setattr_exit;
2818                         }
2819                 } else
2820                 if (((mode & S_IWUGO) == 0) &&
2821                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2822
2823                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2824
2825                         /* fix up mode if we're not using dynperm */
2826                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2827                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2828                 } else if ((mode & S_IWUGO) &&
2829                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2830
2831                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2832                         /* Attributes of 0 are ignored */
2833                         if (dosattr == 0)
2834                                 dosattr |= ATTR_NORMAL;
2835
2836                         /* reset local inode permissions to normal */
2837                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2838                                 attrs->ia_mode &= ~(S_IALLUGO);
2839                                 if (S_ISDIR(inode->i_mode))
2840                                         attrs->ia_mode |=
2841                                                 cifs_sb->mnt_dir_mode;
2842                                 else
2843                                         attrs->ia_mode |=
2844                                                 cifs_sb->mnt_file_mode;
2845                         }
2846                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2847                         /* ignore mode change - ATTR_READONLY hasn't changed */
2848                         attrs->ia_valid &= ~ATTR_MODE;
2849                 }
2850         }
2851
2852         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2853             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2854                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2855                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2856
2857                 /* Even if error on time set, no sense failing the call if
2858                 the server would set the time to a reasonable value anyway,
2859                 and this check ensures that we are not being called from
2860                 sys_utimes in which case we ought to fail the call back to
2861                 the user when the server rejects the call */
2862                 if ((rc) && (attrs->ia_valid &
2863                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2864                         rc = 0;
2865         }
2866
2867         /* do not need local check to inode_check_ok since the server does
2868            that */
2869         if (rc)
2870                 goto cifs_setattr_exit;
2871
2872         if ((attrs->ia_valid & ATTR_SIZE) &&
2873             attrs->ia_size != i_size_read(inode))
2874                 truncate_setsize(inode, attrs->ia_size);
2875
2876         setattr_copy(inode, attrs);
2877         mark_inode_dirty(inode);
2878
2879 cifs_setattr_exit:
2880         kfree(full_path);
2881         free_xid(xid);
2882         return rc;
2883 }
2884
2885 int
2886 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2887 {
2888         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2889         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2890
2891         if (pTcon->unix_ext)
2892                 return cifs_setattr_unix(direntry, attrs);
2893
2894         return cifs_setattr_nounix(direntry, attrs);
2895
2896         /* BB: add cifs_setattr_legacy for really old servers */
2897 }
2898
2899 #if 0
2900 void cifs_delete_inode(struct inode *inode)
2901 {
2902         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2903         /* may have to add back in if and when safe distributed caching of
2904            directories added e.g. via FindNotify */
2905 }
2906 #endif