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          * 4. 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          * 5. 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         rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1337
1338 iget_no_retry:
1339         if (!inode) {
1340                 inode = ERR_PTR(rc);
1341                 goto out;
1342         }
1343
1344 #ifdef CONFIG_CIFS_FSCACHE
1345         /* populate tcon->resource_id */
1346         tcon->resource_id = CIFS_I(inode)->uniqueid;
1347 #endif
1348
1349         if (rc && tcon->pipe) {
1350                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1351                 spin_lock(&inode->i_lock);
1352                 inode->i_mode |= S_IFDIR;
1353                 set_nlink(inode, 2);
1354                 inode->i_op = &cifs_ipc_inode_ops;
1355                 inode->i_fop = &simple_dir_operations;
1356                 inode->i_uid = cifs_sb->mnt_uid;
1357                 inode->i_gid = cifs_sb->mnt_gid;
1358                 spin_unlock(&inode->i_lock);
1359         } else if (rc) {
1360                 iget_failed(inode);
1361                 inode = ERR_PTR(rc);
1362         }
1363
1364 out:
1365         kfree(path);
1366         free_xid(xid);
1367         return inode;
1368 }
1369
1370 int
1371 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1372                    char *full_path, __u32 dosattr)
1373 {
1374         bool set_time = false;
1375         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1376         struct TCP_Server_Info *server;
1377         FILE_BASIC_INFO info_buf;
1378
1379         if (attrs == NULL)
1380                 return -EINVAL;
1381
1382         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1383         if (!server->ops->set_file_info)
1384                 return -ENOSYS;
1385
1386         info_buf.Pad = 0;
1387
1388         if (attrs->ia_valid & ATTR_ATIME) {
1389                 set_time = true;
1390                 info_buf.LastAccessTime =
1391                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1392         } else
1393                 info_buf.LastAccessTime = 0;
1394
1395         if (attrs->ia_valid & ATTR_MTIME) {
1396                 set_time = true;
1397                 info_buf.LastWriteTime =
1398                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1399         } else
1400                 info_buf.LastWriteTime = 0;
1401
1402         /*
1403          * Samba throws this field away, but windows may actually use it.
1404          * Do not set ctime unless other time stamps are changed explicitly
1405          * (i.e. by utimes()) since we would then have a mix of client and
1406          * server times.
1407          */
1408         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1409                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1410                 info_buf.ChangeTime =
1411                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1412         } else
1413                 info_buf.ChangeTime = 0;
1414
1415         info_buf.CreationTime = 0;      /* don't change */
1416         info_buf.Attributes = cpu_to_le32(dosattr);
1417
1418         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1419 }
1420
1421 /*
1422  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1423  * and rename it to a random name that hopefully won't conflict with
1424  * anything else.
1425  */
1426 int
1427 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1428                            const unsigned int xid)
1429 {
1430         int oplock = 0;
1431         int rc;
1432         struct cifs_fid fid;
1433         struct cifs_open_parms oparms;
1434         struct inode *inode = d_inode(dentry);
1435         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1436         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1437         struct tcon_link *tlink;
1438         struct cifs_tcon *tcon;
1439         __u32 dosattr, origattr;
1440         FILE_BASIC_INFO *info_buf = NULL;
1441
1442         tlink = cifs_sb_tlink(cifs_sb);
1443         if (IS_ERR(tlink))
1444                 return PTR_ERR(tlink);
1445         tcon = tlink_tcon(tlink);
1446
1447         /*
1448          * We cannot rename the file if the server doesn't support
1449          * CAP_INFOLEVEL_PASSTHRU
1450          */
1451         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1452                 rc = -EBUSY;
1453                 goto out;
1454         }
1455
1456         oparms.tcon = tcon;
1457         oparms.cifs_sb = cifs_sb;
1458         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1459         oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
1460         oparms.disposition = FILE_OPEN;
1461         oparms.path = full_path;
1462         oparms.fid = &fid;
1463         oparms.reconnect = false;
1464
1465         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1466         if (rc != 0)
1467                 goto out;
1468
1469         origattr = cifsInode->cifsAttrs;
1470         if (origattr == 0)
1471                 origattr |= ATTR_NORMAL;
1472
1473         dosattr = origattr & ~ATTR_READONLY;
1474         if (dosattr == 0)
1475                 dosattr |= ATTR_NORMAL;
1476         dosattr |= ATTR_HIDDEN;
1477
1478         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1479         if (dosattr != origattr) {
1480                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1481                 if (info_buf == NULL) {
1482                         rc = -ENOMEM;
1483                         goto out_close;
1484                 }
1485                 info_buf->Attributes = cpu_to_le32(dosattr);
1486                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1487                                         current->tgid);
1488                 /* although we would like to mark the file hidden
1489                    if that fails we will still try to rename it */
1490                 if (!rc)
1491                         cifsInode->cifsAttrs = dosattr;
1492                 else
1493                         dosattr = origattr; /* since not able to change them */
1494         }
1495
1496         /* rename the file */
1497         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1498                                    cifs_sb->local_nls,
1499                                    cifs_remap(cifs_sb));
1500         if (rc != 0) {
1501                 rc = -EBUSY;
1502                 goto undo_setattr;
1503         }
1504
1505         /* try to set DELETE_ON_CLOSE */
1506         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1507                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1508                                                current->tgid);
1509                 /*
1510                  * some samba versions return -ENOENT when we try to set the
1511                  * file disposition here. Likely a samba bug, but work around
1512                  * it for now. This means that some cifsXXX files may hang
1513                  * around after they shouldn't.
1514                  *
1515                  * BB: remove this hack after more servers have the fix
1516                  */
1517                 if (rc == -ENOENT)
1518                         rc = 0;
1519                 else if (rc != 0) {
1520                         rc = -EBUSY;
1521                         goto undo_rename;
1522                 }
1523                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1524         }
1525
1526 out_close:
1527         CIFSSMBClose(xid, tcon, fid.netfid);
1528 out:
1529         kfree(info_buf);
1530         cifs_put_tlink(tlink);
1531         return rc;
1532
1533         /*
1534          * reset everything back to the original state. Don't bother
1535          * dealing with errors here since we can't do anything about
1536          * them anyway.
1537          */
1538 undo_rename:
1539         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1540                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1541 undo_setattr:
1542         if (dosattr != origattr) {
1543                 info_buf->Attributes = cpu_to_le32(origattr);
1544                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1545                                         current->tgid))
1546                         cifsInode->cifsAttrs = origattr;
1547         }
1548
1549         goto out_close;
1550 }
1551
1552 /* copied from fs/nfs/dir.c with small changes */
1553 static void
1554 cifs_drop_nlink(struct inode *inode)
1555 {
1556         spin_lock(&inode->i_lock);
1557         if (inode->i_nlink > 0)
1558                 drop_nlink(inode);
1559         spin_unlock(&inode->i_lock);
1560 }
1561
1562 /*
1563  * If d_inode(dentry) is null (usually meaning the cached dentry
1564  * is a negative dentry) then we would attempt a standard SMB delete, but
1565  * if that fails we can not attempt the fall back mechanisms on EACCES
1566  * but will return the EACCES to the caller. Note that the VFS does not call
1567  * unlink on negative dentries currently.
1568  */
1569 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1570 {
1571         int rc = 0;
1572         unsigned int xid;
1573         char *full_path = NULL;
1574         struct inode *inode = d_inode(dentry);
1575         struct cifsInodeInfo *cifs_inode;
1576         struct super_block *sb = dir->i_sb;
1577         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1578         struct tcon_link *tlink;
1579         struct cifs_tcon *tcon;
1580         struct TCP_Server_Info *server;
1581         struct iattr *attrs = NULL;
1582         __u32 dosattr = 0, origattr = 0;
1583
1584         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1585
1586         tlink = cifs_sb_tlink(cifs_sb);
1587         if (IS_ERR(tlink))
1588                 return PTR_ERR(tlink);
1589         tcon = tlink_tcon(tlink);
1590         server = tcon->ses->server;
1591
1592         xid = get_xid();
1593
1594         if (tcon->nodelete) {
1595                 rc = -EACCES;
1596                 goto unlink_out;
1597         }
1598
1599         /* Unlink can be called from rename so we can not take the
1600          * sb->s_vfs_rename_mutex here */
1601         full_path = build_path_from_dentry(dentry);
1602         if (full_path == NULL) {
1603                 rc = -ENOMEM;
1604                 goto unlink_out;
1605         }
1606
1607         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1608                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1609                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1610                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1611                         cifs_remap(cifs_sb));
1612                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1613                 if ((rc == 0) || (rc == -ENOENT))
1614                         goto psx_del_no_retry;
1615         }
1616
1617 retry_std_delete:
1618         if (!server->ops->unlink) {
1619                 rc = -ENOSYS;
1620                 goto psx_del_no_retry;
1621         }
1622
1623         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1624
1625 psx_del_no_retry:
1626         if (!rc) {
1627                 if (inode)
1628                         cifs_drop_nlink(inode);
1629         } else if (rc == -ENOENT) {
1630                 d_drop(dentry);
1631         } else if (rc == -EBUSY) {
1632                 if (server->ops->rename_pending_delete) {
1633                         rc = server->ops->rename_pending_delete(full_path,
1634                                                                 dentry, xid);
1635                         if (rc == 0)
1636                                 cifs_drop_nlink(inode);
1637                 }
1638         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1639                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1640                 if (attrs == NULL) {
1641                         rc = -ENOMEM;
1642                         goto out_reval;
1643                 }
1644
1645                 /* try to reset dos attributes */
1646                 cifs_inode = CIFS_I(inode);
1647                 origattr = cifs_inode->cifsAttrs;
1648                 if (origattr == 0)
1649                         origattr |= ATTR_NORMAL;
1650                 dosattr = origattr & ~ATTR_READONLY;
1651                 if (dosattr == 0)
1652                         dosattr |= ATTR_NORMAL;
1653                 dosattr |= ATTR_HIDDEN;
1654
1655                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1656                 if (rc != 0)
1657                         goto out_reval;
1658
1659                 goto retry_std_delete;
1660         }
1661
1662         /* undo the setattr if we errored out and it's needed */
1663         if (rc != 0 && dosattr != 0)
1664                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1665
1666 out_reval:
1667         if (inode) {
1668                 cifs_inode = CIFS_I(inode);
1669                 cifs_inode->time = 0;   /* will force revalidate to get info
1670                                            when needed */
1671                 inode->i_ctime = current_time(inode);
1672         }
1673         dir->i_ctime = dir->i_mtime = current_time(dir);
1674         cifs_inode = CIFS_I(dir);
1675         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1676 unlink_out:
1677         kfree(full_path);
1678         kfree(attrs);
1679         free_xid(xid);
1680         cifs_put_tlink(tlink);
1681         return rc;
1682 }
1683
1684 static int
1685 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1686                  const char *full_path, struct cifs_sb_info *cifs_sb,
1687                  struct cifs_tcon *tcon, const unsigned int xid)
1688 {
1689         int rc = 0;
1690         struct inode *inode = NULL;
1691
1692         if (tcon->unix_ext)
1693                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1694                                               xid);
1695         else
1696                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1697                                          xid, NULL);
1698
1699         if (rc)
1700                 return rc;
1701
1702         /*
1703          * setting nlink not necessary except in cases where we failed to get it
1704          * from the server or was set bogus. Also, since this is a brand new
1705          * inode, no need to grab the i_lock before setting the i_nlink.
1706          */
1707         if (inode->i_nlink < 2)
1708                 set_nlink(inode, 2);
1709         mode &= ~current_umask();
1710         /* must turn on setgid bit if parent dir has it */
1711         if (parent->i_mode & S_ISGID)
1712                 mode |= S_ISGID;
1713
1714         if (tcon->unix_ext) {
1715                 struct cifs_unix_set_info_args args = {
1716                         .mode   = mode,
1717                         .ctime  = NO_CHANGE_64,
1718                         .atime  = NO_CHANGE_64,
1719                         .mtime  = NO_CHANGE_64,
1720                         .device = 0,
1721                 };
1722                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1723                         args.uid = current_fsuid();
1724                         if (parent->i_mode & S_ISGID)
1725                                 args.gid = parent->i_gid;
1726                         else
1727                                 args.gid = current_fsgid();
1728                 } else {
1729                         args.uid = INVALID_UID; /* no change */
1730                         args.gid = INVALID_GID; /* no change */
1731                 }
1732                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1733                                        cifs_sb->local_nls,
1734                                        cifs_remap(cifs_sb));
1735         } else {
1736                 struct TCP_Server_Info *server = tcon->ses->server;
1737                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1738                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1739                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1740                                                    tcon, xid);
1741                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1742                         inode->i_mode = (mode | S_IFDIR);
1743
1744                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1745                         inode->i_uid = current_fsuid();
1746                         if (inode->i_mode & S_ISGID)
1747                                 inode->i_gid = parent->i_gid;
1748                         else
1749                                 inode->i_gid = current_fsgid();
1750                 }
1751         }
1752         d_instantiate(dentry, inode);
1753         return rc;
1754 }
1755
1756 static int
1757 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1758                  const char *full_path, struct cifs_sb_info *cifs_sb,
1759                  struct cifs_tcon *tcon, const unsigned int xid)
1760 {
1761         int rc = 0;
1762         u32 oplock = 0;
1763         FILE_UNIX_BASIC_INFO *info = NULL;
1764         struct inode *newinode = NULL;
1765         struct cifs_fattr fattr;
1766
1767         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1768         if (info == NULL) {
1769                 rc = -ENOMEM;
1770                 goto posix_mkdir_out;
1771         }
1772
1773         mode &= ~current_umask();
1774         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1775                              NULL /* netfid */, info, &oplock, full_path,
1776                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1777         if (rc == -EOPNOTSUPP)
1778                 goto posix_mkdir_out;
1779         else if (rc) {
1780                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1781                 d_drop(dentry);
1782                 goto posix_mkdir_out;
1783         }
1784
1785         if (info->Type == cpu_to_le32(-1))
1786                 /* no return info, go query for it */
1787                 goto posix_mkdir_get_info;
1788         /*
1789          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1790          * need to set uid/gid.
1791          */
1792
1793         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1794         cifs_fill_uniqueid(inode->i_sb, &fattr);
1795         newinode = cifs_iget(inode->i_sb, &fattr);
1796         if (!newinode)
1797                 goto posix_mkdir_get_info;
1798
1799         d_instantiate(dentry, newinode);
1800
1801 #ifdef CONFIG_CIFS_DEBUG2
1802         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1803                  dentry, dentry, newinode);
1804
1805         if (newinode->i_nlink != 2)
1806                 cifs_dbg(FYI, "unexpected number of links %d\n",
1807                          newinode->i_nlink);
1808 #endif
1809
1810 posix_mkdir_out:
1811         kfree(info);
1812         return rc;
1813 posix_mkdir_get_info:
1814         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1815                               xid);
1816         goto posix_mkdir_out;
1817 }
1818
1819 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1820 {
1821         int rc = 0;
1822         unsigned int xid;
1823         struct cifs_sb_info *cifs_sb;
1824         struct tcon_link *tlink;
1825         struct cifs_tcon *tcon;
1826         struct TCP_Server_Info *server;
1827         char *full_path;
1828
1829         cifs_dbg(FYI, "In cifs_mkdir, mode = %04ho inode = 0x%p\n",
1830                  mode, inode);
1831
1832         cifs_sb = CIFS_SB(inode->i_sb);
1833         tlink = cifs_sb_tlink(cifs_sb);
1834         if (IS_ERR(tlink))
1835                 return PTR_ERR(tlink);
1836         tcon = tlink_tcon(tlink);
1837
1838         xid = get_xid();
1839
1840         full_path = build_path_from_dentry(direntry);
1841         if (full_path == NULL) {
1842                 rc = -ENOMEM;
1843                 goto mkdir_out;
1844         }
1845
1846         server = tcon->ses->server;
1847
1848         if ((server->ops->posix_mkdir) && (tcon->posix_extensions)) {
1849                 rc = server->ops->posix_mkdir(xid, inode, mode, tcon, full_path,
1850                                               cifs_sb);
1851                 d_drop(direntry); /* for time being always refresh inode info */
1852                 goto mkdir_out;
1853         }
1854
1855         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1856                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1857                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1858                                       tcon, xid);
1859                 if (rc != -EOPNOTSUPP)
1860                         goto mkdir_out;
1861         }
1862
1863         if (!server->ops->mkdir) {
1864                 rc = -ENOSYS;
1865                 goto mkdir_out;
1866         }
1867
1868         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1869         rc = server->ops->mkdir(xid, inode, mode, tcon, full_path, cifs_sb);
1870         if (rc) {
1871                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1872                 d_drop(direntry);
1873                 goto mkdir_out;
1874         }
1875
1876         /* TODO: skip this for smb2/smb3 */
1877         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1878                               xid);
1879 mkdir_out:
1880         /*
1881          * Force revalidate to get parent dir info when needed since cached
1882          * attributes are invalid now.
1883          */
1884         CIFS_I(inode)->time = 0;
1885         kfree(full_path);
1886         free_xid(xid);
1887         cifs_put_tlink(tlink);
1888         return rc;
1889 }
1890
1891 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1892 {
1893         int rc = 0;
1894         unsigned int xid;
1895         struct cifs_sb_info *cifs_sb;
1896         struct tcon_link *tlink;
1897         struct cifs_tcon *tcon;
1898         struct TCP_Server_Info *server;
1899         char *full_path = NULL;
1900         struct cifsInodeInfo *cifsInode;
1901
1902         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1903
1904         xid = get_xid();
1905
1906         full_path = build_path_from_dentry(direntry);
1907         if (full_path == NULL) {
1908                 rc = -ENOMEM;
1909                 goto rmdir_exit;
1910         }
1911
1912         cifs_sb = CIFS_SB(inode->i_sb);
1913         tlink = cifs_sb_tlink(cifs_sb);
1914         if (IS_ERR(tlink)) {
1915                 rc = PTR_ERR(tlink);
1916                 goto rmdir_exit;
1917         }
1918         tcon = tlink_tcon(tlink);
1919         server = tcon->ses->server;
1920
1921         if (!server->ops->rmdir) {
1922                 rc = -ENOSYS;
1923                 cifs_put_tlink(tlink);
1924                 goto rmdir_exit;
1925         }
1926
1927         if (tcon->nodelete) {
1928                 rc = -EACCES;
1929                 cifs_put_tlink(tlink);
1930                 goto rmdir_exit;
1931         }
1932
1933         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1934         cifs_put_tlink(tlink);
1935
1936         if (!rc) {
1937                 spin_lock(&d_inode(direntry)->i_lock);
1938                 i_size_write(d_inode(direntry), 0);
1939                 clear_nlink(d_inode(direntry));
1940                 spin_unlock(&d_inode(direntry)->i_lock);
1941         }
1942
1943         cifsInode = CIFS_I(d_inode(direntry));
1944         /* force revalidate to go get info when needed */
1945         cifsInode->time = 0;
1946
1947         cifsInode = CIFS_I(inode);
1948         /*
1949          * Force revalidate to get parent dir info when needed since cached
1950          * attributes are invalid now.
1951          */
1952         cifsInode->time = 0;
1953
1954         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1955                 current_time(inode);
1956
1957 rmdir_exit:
1958         kfree(full_path);
1959         free_xid(xid);
1960         return rc;
1961 }
1962
1963 static int
1964 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1965                const char *from_path, struct dentry *to_dentry,
1966                const char *to_path)
1967 {
1968         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1969         struct tcon_link *tlink;
1970         struct cifs_tcon *tcon;
1971         struct TCP_Server_Info *server;
1972         struct cifs_fid fid;
1973         struct cifs_open_parms oparms;
1974         int oplock, rc;
1975
1976         tlink = cifs_sb_tlink(cifs_sb);
1977         if (IS_ERR(tlink))
1978                 return PTR_ERR(tlink);
1979         tcon = tlink_tcon(tlink);
1980         server = tcon->ses->server;
1981
1982         if (!server->ops->rename)
1983                 return -ENOSYS;
1984
1985         /* try path-based rename first */
1986         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1987
1988         /*
1989          * Don't bother with rename by filehandle unless file is busy and
1990          * source. Note that cross directory moves do not work with
1991          * rename by filehandle to various Windows servers.
1992          */
1993         if (rc == 0 || rc != -EBUSY)
1994                 goto do_rename_exit;
1995
1996         /* Don't fall back to using SMB on SMB 2+ mount */
1997         if (server->vals->protocol_id != 0)
1998                 goto do_rename_exit;
1999
2000         /* open-file renames don't work across directories */
2001         if (to_dentry->d_parent != from_dentry->d_parent)
2002                 goto do_rename_exit;
2003
2004         oparms.tcon = tcon;
2005         oparms.cifs_sb = cifs_sb;
2006         /* open the file to be renamed -- we need DELETE perms */
2007         oparms.desired_access = DELETE;
2008         oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
2009         oparms.disposition = FILE_OPEN;
2010         oparms.path = from_path;
2011         oparms.fid = &fid;
2012         oparms.reconnect = false;
2013
2014         rc = CIFS_open(xid, &oparms, &oplock, NULL);
2015         if (rc == 0) {
2016                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
2017                                 (const char *) to_dentry->d_name.name,
2018                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
2019                 CIFSSMBClose(xid, tcon, fid.netfid);
2020         }
2021 do_rename_exit:
2022         if (rc == 0)
2023                 d_move(from_dentry, to_dentry);
2024         cifs_put_tlink(tlink);
2025         return rc;
2026 }
2027
2028 int
2029 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
2030              struct inode *target_dir, struct dentry *target_dentry,
2031              unsigned int flags)
2032 {
2033         char *from_name = NULL;
2034         char *to_name = NULL;
2035         struct cifs_sb_info *cifs_sb;
2036         struct tcon_link *tlink;
2037         struct cifs_tcon *tcon;
2038         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
2039         FILE_UNIX_BASIC_INFO *info_buf_target;
2040         unsigned int xid;
2041         int rc, tmprc;
2042
2043         if (flags & ~RENAME_NOREPLACE)
2044                 return -EINVAL;
2045
2046         cifs_sb = CIFS_SB(source_dir->i_sb);
2047         tlink = cifs_sb_tlink(cifs_sb);
2048         if (IS_ERR(tlink))
2049                 return PTR_ERR(tlink);
2050         tcon = tlink_tcon(tlink);
2051
2052         xid = get_xid();
2053
2054         /*
2055          * we already have the rename sem so we do not need to
2056          * grab it again here to protect the path integrity
2057          */
2058         from_name = build_path_from_dentry(source_dentry);
2059         if (from_name == NULL) {
2060                 rc = -ENOMEM;
2061                 goto cifs_rename_exit;
2062         }
2063
2064         to_name = build_path_from_dentry(target_dentry);
2065         if (to_name == NULL) {
2066                 rc = -ENOMEM;
2067                 goto cifs_rename_exit;
2068         }
2069
2070         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
2071                             to_name);
2072
2073         /*
2074          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
2075          */
2076         if (flags & RENAME_NOREPLACE)
2077                 goto cifs_rename_exit;
2078
2079         if (rc == -EEXIST && tcon->unix_ext) {
2080                 /*
2081                  * Are src and dst hardlinks of same inode? We can only tell
2082                  * with unix extensions enabled.
2083                  */
2084                 info_buf_source =
2085                         kmalloc_array(2, sizeof(FILE_UNIX_BASIC_INFO),
2086                                         GFP_KERNEL);
2087                 if (info_buf_source == NULL) {
2088                         rc = -ENOMEM;
2089                         goto cifs_rename_exit;
2090                 }
2091
2092                 info_buf_target = info_buf_source + 1;
2093                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
2094                                              info_buf_source,
2095                                              cifs_sb->local_nls,
2096                                              cifs_remap(cifs_sb));
2097                 if (tmprc != 0)
2098                         goto unlink_target;
2099
2100                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
2101                                              info_buf_target,
2102                                              cifs_sb->local_nls,
2103                                              cifs_remap(cifs_sb));
2104
2105                 if (tmprc == 0 && (info_buf_source->UniqueId ==
2106                                    info_buf_target->UniqueId)) {
2107                         /* same file, POSIX says that this is a noop */
2108                         rc = 0;
2109                         goto cifs_rename_exit;
2110                 }
2111         }
2112         /*
2113          * else ... BB we could add the same check for Windows by
2114          * checking the UniqueId via FILE_INTERNAL_INFO
2115          */
2116
2117 unlink_target:
2118         /* Try unlinking the target dentry if it's not negative */
2119         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
2120                 if (d_is_dir(target_dentry))
2121                         tmprc = cifs_rmdir(target_dir, target_dentry);
2122                 else
2123                         tmprc = cifs_unlink(target_dir, target_dentry);
2124                 if (tmprc)
2125                         goto cifs_rename_exit;
2126                 rc = cifs_do_rename(xid, source_dentry, from_name,
2127                                     target_dentry, to_name);
2128         }
2129
2130         /* force revalidate to go get info when needed */
2131         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
2132
2133         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
2134                 target_dir->i_mtime = current_time(source_dir);
2135
2136 cifs_rename_exit:
2137         kfree(info_buf_source);
2138         kfree(from_name);
2139         kfree(to_name);
2140         free_xid(xid);
2141         cifs_put_tlink(tlink);
2142         return rc;
2143 }
2144
2145 static bool
2146 cifs_inode_needs_reval(struct inode *inode)
2147 {
2148         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2149         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2150
2151         if (cifs_i->time == 0)
2152                 return true;
2153
2154         if (CIFS_CACHE_READ(cifs_i))
2155                 return false;
2156
2157         if (!lookupCacheEnabled)
2158                 return true;
2159
2160         if (!cifs_sb->actimeo)
2161                 return true;
2162
2163         if (!time_in_range(jiffies, cifs_i->time,
2164                                 cifs_i->time + cifs_sb->actimeo))
2165                 return true;
2166
2167         /* hardlinked files w/ noserverino get "special" treatment */
2168         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
2169             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
2170                 return true;
2171
2172         return false;
2173 }
2174
2175 /*
2176  * Zap the cache. Called when invalid_mapping flag is set.
2177  */
2178 int
2179 cifs_invalidate_mapping(struct inode *inode)
2180 {
2181         int rc = 0;
2182
2183         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
2184                 rc = invalidate_inode_pages2(inode->i_mapping);
2185                 if (rc)
2186                         cifs_dbg(VFS, "%s: Could not invalidate inode %p\n",
2187                                  __func__, inode);
2188         }
2189
2190         cifs_fscache_reset_inode_cookie(inode);
2191         return rc;
2192 }
2193
2194 /**
2195  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
2196  * @word: long word containing the bit lock
2197  */
2198 static int
2199 cifs_wait_bit_killable(struct wait_bit_key *key, int mode)
2200 {
2201         freezable_schedule_unsafe();
2202         if (signal_pending_state(mode, current))
2203                 return -ERESTARTSYS;
2204         return 0;
2205 }
2206
2207 int
2208 cifs_revalidate_mapping(struct inode *inode)
2209 {
2210         int rc;
2211         unsigned long *flags = &CIFS_I(inode)->flags;
2212
2213         /* swapfiles are not supposed to be shared */
2214         if (IS_SWAPFILE(inode))
2215                 return 0;
2216
2217         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
2218                                      TASK_KILLABLE);
2219         if (rc)
2220                 return rc;
2221
2222         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
2223                 rc = cifs_invalidate_mapping(inode);
2224                 if (rc)
2225                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
2226         }
2227
2228         clear_bit_unlock(CIFS_INO_LOCK, flags);
2229         smp_mb__after_atomic();
2230         wake_up_bit(flags, CIFS_INO_LOCK);
2231
2232         return rc;
2233 }
2234
2235 int
2236 cifs_zap_mapping(struct inode *inode)
2237 {
2238         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
2239         return cifs_revalidate_mapping(inode);
2240 }
2241
2242 int cifs_revalidate_file_attr(struct file *filp)
2243 {
2244         int rc = 0;
2245         struct inode *inode = file_inode(filp);
2246         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
2247
2248         if (!cifs_inode_needs_reval(inode))
2249                 return rc;
2250
2251         if (tlink_tcon(cfile->tlink)->unix_ext)
2252                 rc = cifs_get_file_info_unix(filp);
2253         else
2254                 rc = cifs_get_file_info(filp);
2255
2256         return rc;
2257 }
2258
2259 int cifs_revalidate_dentry_attr(struct dentry *dentry)
2260 {
2261         unsigned int xid;
2262         int rc = 0;
2263         struct inode *inode = d_inode(dentry);
2264         struct super_block *sb = dentry->d_sb;
2265         char *full_path = NULL;
2266         int count = 0;
2267
2268         if (inode == NULL)
2269                 return -ENOENT;
2270
2271         if (!cifs_inode_needs_reval(inode))
2272                 return rc;
2273
2274         xid = get_xid();
2275
2276         /* can not safely grab the rename sem here if rename calls revalidate
2277            since that would deadlock */
2278         full_path = build_path_from_dentry(dentry);
2279         if (full_path == NULL) {
2280                 rc = -ENOMEM;
2281                 goto out;
2282         }
2283
2284         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
2285                  full_path, inode, inode->i_count.counter,
2286                  dentry, cifs_get_time(dentry), jiffies);
2287
2288 again:
2289         if (cifs_sb_master_tcon(CIFS_SB(sb))->posix_extensions)
2290                 rc = smb311_posix_get_inode_info(&inode, full_path, sb, xid);
2291         else if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
2292                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
2293         else
2294                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
2295                                          xid, NULL);
2296         if (rc == -EAGAIN && count++ < 10)
2297                 goto again;
2298 out:
2299         kfree(full_path);
2300         free_xid(xid);
2301
2302         return rc;
2303 }
2304
2305 int cifs_revalidate_file(struct file *filp)
2306 {
2307         int rc;
2308         struct inode *inode = file_inode(filp);
2309
2310         rc = cifs_revalidate_file_attr(filp);
2311         if (rc)
2312                 return rc;
2313
2314         return cifs_revalidate_mapping(inode);
2315 }
2316
2317 /* revalidate a dentry's inode attributes */
2318 int cifs_revalidate_dentry(struct dentry *dentry)
2319 {
2320         int rc;
2321         struct inode *inode = d_inode(dentry);
2322
2323         rc = cifs_revalidate_dentry_attr(dentry);
2324         if (rc)
2325                 return rc;
2326
2327         return cifs_revalidate_mapping(inode);
2328 }
2329
2330 int cifs_getattr(const struct path *path, struct kstat *stat,
2331                  u32 request_mask, unsigned int flags)
2332 {
2333         struct dentry *dentry = path->dentry;
2334         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
2335         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2336         struct inode *inode = d_inode(dentry);
2337         int rc;
2338
2339         /*
2340          * We need to be sure that all dirty pages are written and the server
2341          * has actual ctime, mtime and file length.
2342          */
2343         if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_SIZE)) &&
2344             !CIFS_CACHE_READ(CIFS_I(inode)) &&
2345             inode->i_mapping && inode->i_mapping->nrpages != 0) {
2346                 rc = filemap_fdatawait(inode->i_mapping);
2347                 if (rc) {
2348                         mapping_set_error(inode->i_mapping, rc);
2349                         return rc;
2350                 }
2351         }
2352
2353         if ((flags & AT_STATX_SYNC_TYPE) == AT_STATX_FORCE_SYNC)
2354                 CIFS_I(inode)->time = 0; /* force revalidate */
2355
2356         /*
2357          * If the caller doesn't require syncing, only sync if
2358          * necessary (e.g. due to earlier truncate or setattr
2359          * invalidating the cached metadata)
2360          */
2361         if (((flags & AT_STATX_SYNC_TYPE) != AT_STATX_DONT_SYNC) ||
2362             (CIFS_I(inode)->time == 0)) {
2363                 rc = cifs_revalidate_dentry_attr(dentry);
2364                 if (rc)
2365                         return rc;
2366         }
2367
2368         generic_fillattr(inode, stat);
2369         stat->blksize = cifs_sb->bsize;
2370         stat->ino = CIFS_I(inode)->uniqueid;
2371
2372         /* old CIFS Unix Extensions doesn't return create time */
2373         if (CIFS_I(inode)->createtime) {
2374                 stat->result_mask |= STATX_BTIME;
2375                 stat->btime =
2376                       cifs_NTtimeToUnix(cpu_to_le64(CIFS_I(inode)->createtime));
2377         }
2378
2379         stat->attributes_mask |= (STATX_ATTR_COMPRESSED | STATX_ATTR_ENCRYPTED);
2380         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_COMPRESSED)
2381                 stat->attributes |= STATX_ATTR_COMPRESSED;
2382         if (CIFS_I(inode)->cifsAttrs & FILE_ATTRIBUTE_ENCRYPTED)
2383                 stat->attributes |= STATX_ATTR_ENCRYPTED;
2384
2385         /*
2386          * If on a multiuser mount without unix extensions or cifsacl being
2387          * enabled, and the admin hasn't overridden them, set the ownership
2388          * to the fsuid/fsgid of the current process.
2389          */
2390         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2391             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2392             !tcon->unix_ext) {
2393                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2394                         stat->uid = current_fsuid();
2395                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2396                         stat->gid = current_fsgid();
2397         }
2398         return 0;
2399 }
2400
2401 int cifs_fiemap(struct inode *inode, struct fiemap_extent_info *fei, u64 start,
2402                 u64 len)
2403 {
2404         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2405         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_i->vfs_inode.i_sb);
2406         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
2407         struct TCP_Server_Info *server = tcon->ses->server;
2408         struct cifsFileInfo *cfile;
2409         int rc;
2410
2411         /*
2412          * We need to be sure that all dirty pages are written as they
2413          * might fill holes on the server.
2414          */
2415         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
2416             inode->i_mapping->nrpages != 0) {
2417                 rc = filemap_fdatawait(inode->i_mapping);
2418                 if (rc) {
2419                         mapping_set_error(inode->i_mapping, rc);
2420                         return rc;
2421                 }
2422         }
2423
2424         cfile = find_readable_file(cifs_i, false);
2425         if (cfile == NULL)
2426                 return -EINVAL;
2427
2428         if (server->ops->fiemap) {
2429                 rc = server->ops->fiemap(tcon, cfile, fei, start, len);
2430                 cifsFileInfo_put(cfile);
2431                 return rc;
2432         }
2433
2434         cifsFileInfo_put(cfile);
2435         return -ENOTSUPP;
2436 }
2437
2438 int cifs_truncate_page(struct address_space *mapping, loff_t from)
2439 {
2440         pgoff_t index = from >> PAGE_SHIFT;
2441         unsigned offset = from & (PAGE_SIZE - 1);
2442         struct page *page;
2443         int rc = 0;
2444
2445         page = grab_cache_page(mapping, index);
2446         if (!page)
2447                 return -ENOMEM;
2448
2449         zero_user_segment(page, offset, PAGE_SIZE);
2450         unlock_page(page);
2451         put_page(page);
2452         return rc;
2453 }
2454
2455 void cifs_setsize(struct inode *inode, loff_t offset)
2456 {
2457         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
2458
2459         spin_lock(&inode->i_lock);
2460         i_size_write(inode, offset);
2461         spin_unlock(&inode->i_lock);
2462
2463         /* Cached inode must be refreshed on truncate */
2464         cifs_i->time = 0;
2465         truncate_pagecache(inode, offset);
2466 }
2467
2468 static int
2469 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2470                    unsigned int xid, char *full_path)
2471 {
2472         int rc;
2473         struct cifsFileInfo *open_file;
2474         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2475         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2476         struct tcon_link *tlink = NULL;
2477         struct cifs_tcon *tcon = NULL;
2478         struct TCP_Server_Info *server;
2479
2480         /*
2481          * To avoid spurious oplock breaks from server, in the case of
2482          * inodes that we already have open, avoid doing path based
2483          * setting of file size if we can do it by handle.
2484          * This keeps our caching token (oplock) and avoids timeouts
2485          * when the local oplock break takes longer to flush
2486          * writebehind data than the SMB timeout for the SetPathInfo
2487          * request would allow
2488          */
2489         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2490         if (open_file) {
2491                 tcon = tlink_tcon(open_file->tlink);
2492                 server = tcon->ses->server;
2493                 if (server->ops->set_file_size)
2494                         rc = server->ops->set_file_size(xid, tcon, open_file,
2495                                                         attrs->ia_size, false);
2496                 else
2497                         rc = -ENOSYS;
2498                 cifsFileInfo_put(open_file);
2499                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2500         } else
2501                 rc = -EINVAL;
2502
2503         if (!rc)
2504                 goto set_size_out;
2505
2506         if (tcon == NULL) {
2507                 tlink = cifs_sb_tlink(cifs_sb);
2508                 if (IS_ERR(tlink))
2509                         return PTR_ERR(tlink);
2510                 tcon = tlink_tcon(tlink);
2511                 server = tcon->ses->server;
2512         }
2513
2514         /*
2515          * Set file size by pathname rather than by handle either because no
2516          * valid, writeable file handle for it was found or because there was
2517          * an error setting it by handle.
2518          */
2519         if (server->ops->set_path_size)
2520                 rc = server->ops->set_path_size(xid, tcon, full_path,
2521                                                 attrs->ia_size, cifs_sb, false);
2522         else
2523                 rc = -ENOSYS;
2524         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2525
2526         if (tlink)
2527                 cifs_put_tlink(tlink);
2528
2529 set_size_out:
2530         if (rc == 0) {
2531                 cifsInode->server_eof = attrs->ia_size;
2532                 cifs_setsize(inode, attrs->ia_size);
2533                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2534         }
2535
2536         return rc;
2537 }
2538
2539 static int
2540 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2541 {
2542         int rc;
2543         unsigned int xid;
2544         char *full_path = NULL;
2545         struct inode *inode = d_inode(direntry);
2546         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2547         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2548         struct tcon_link *tlink;
2549         struct cifs_tcon *pTcon;
2550         struct cifs_unix_set_info_args *args = NULL;
2551         struct cifsFileInfo *open_file;
2552
2553         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2554                  direntry, attrs->ia_valid);
2555
2556         xid = get_xid();
2557
2558         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2559                 attrs->ia_valid |= ATTR_FORCE;
2560
2561         rc = setattr_prepare(direntry, attrs);
2562         if (rc < 0)
2563                 goto out;
2564
2565         full_path = build_path_from_dentry(direntry);
2566         if (full_path == NULL) {
2567                 rc = -ENOMEM;
2568                 goto out;
2569         }
2570
2571         /*
2572          * Attempt to flush data before changing attributes. We need to do
2573          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2574          * ownership or mode then we may also need to do this. Here, we take
2575          * the safe way out and just do the flush on all setattr requests. If
2576          * the flush returns error, store it to report later and continue.
2577          *
2578          * BB: This should be smarter. Why bother flushing pages that
2579          * will be truncated anyway? Also, should we error out here if
2580          * the flush returns error?
2581          */
2582         rc = filemap_write_and_wait(inode->i_mapping);
2583         if (is_interrupt_error(rc)) {
2584                 rc = -ERESTARTSYS;
2585                 goto out;
2586         }
2587
2588         mapping_set_error(inode->i_mapping, rc);
2589         rc = 0;
2590
2591         if (attrs->ia_valid & ATTR_SIZE) {
2592                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2593                 if (rc != 0)
2594                         goto out;
2595         }
2596
2597         /* skip mode change if it's just for clearing setuid/setgid */
2598         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2599                 attrs->ia_valid &= ~ATTR_MODE;
2600
2601         args = kmalloc(sizeof(*args), GFP_KERNEL);
2602         if (args == NULL) {
2603                 rc = -ENOMEM;
2604                 goto out;
2605         }
2606
2607         /* set up the struct */
2608         if (attrs->ia_valid & ATTR_MODE)
2609                 args->mode = attrs->ia_mode;
2610         else
2611                 args->mode = NO_CHANGE_64;
2612
2613         if (attrs->ia_valid & ATTR_UID)
2614                 args->uid = attrs->ia_uid;
2615         else
2616                 args->uid = INVALID_UID; /* no change */
2617
2618         if (attrs->ia_valid & ATTR_GID)
2619                 args->gid = attrs->ia_gid;
2620         else
2621                 args->gid = INVALID_GID; /* no change */
2622
2623         if (attrs->ia_valid & ATTR_ATIME)
2624                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2625         else
2626                 args->atime = NO_CHANGE_64;
2627
2628         if (attrs->ia_valid & ATTR_MTIME)
2629                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2630         else
2631                 args->mtime = NO_CHANGE_64;
2632
2633         if (attrs->ia_valid & ATTR_CTIME)
2634                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2635         else
2636                 args->ctime = NO_CHANGE_64;
2637
2638         args->device = 0;
2639         open_file = find_writable_file(cifsInode, FIND_WR_FSUID_ONLY);
2640         if (open_file) {
2641                 u16 nfid = open_file->fid.netfid;
2642                 u32 npid = open_file->pid;
2643                 pTcon = tlink_tcon(open_file->tlink);
2644                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2645                 cifsFileInfo_put(open_file);
2646         } else {
2647                 tlink = cifs_sb_tlink(cifs_sb);
2648                 if (IS_ERR(tlink)) {
2649                         rc = PTR_ERR(tlink);
2650                         goto out;
2651                 }
2652                 pTcon = tlink_tcon(tlink);
2653                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2654                                     cifs_sb->local_nls,
2655                                     cifs_remap(cifs_sb));
2656                 cifs_put_tlink(tlink);
2657         }
2658
2659         if (rc)
2660                 goto out;
2661
2662         if ((attrs->ia_valid & ATTR_SIZE) &&
2663             attrs->ia_size != i_size_read(inode))
2664                 truncate_setsize(inode, attrs->ia_size);
2665
2666         setattr_copy(inode, attrs);
2667         mark_inode_dirty(inode);
2668
2669         /* force revalidate when any of these times are set since some
2670            of the fs types (eg ext3, fat) do not have fine enough
2671            time granularity to match protocol, and we do not have a
2672            a way (yet) to query the server fs's time granularity (and
2673            whether it rounds times down).
2674         */
2675         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2676                 cifsInode->time = 0;
2677 out:
2678         kfree(args);
2679         kfree(full_path);
2680         free_xid(xid);
2681         return rc;
2682 }
2683
2684 static int
2685 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2686 {
2687         unsigned int xid;
2688         kuid_t uid = INVALID_UID;
2689         kgid_t gid = INVALID_GID;
2690         struct inode *inode = d_inode(direntry);
2691         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2692         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2693         struct cifsFileInfo *wfile;
2694         struct cifs_tcon *tcon;
2695         char *full_path = NULL;
2696         int rc = -EACCES;
2697         __u32 dosattr = 0;
2698         __u64 mode = NO_CHANGE_64;
2699
2700         xid = get_xid();
2701
2702         cifs_dbg(FYI, "setattr on file %pd attrs->ia_valid 0x%x\n",
2703                  direntry, attrs->ia_valid);
2704
2705         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2706                 attrs->ia_valid |= ATTR_FORCE;
2707
2708         rc = setattr_prepare(direntry, attrs);
2709         if (rc < 0) {
2710                 free_xid(xid);
2711                 return rc;
2712         }
2713
2714         full_path = build_path_from_dentry(direntry);
2715         if (full_path == NULL) {
2716                 rc = -ENOMEM;
2717                 free_xid(xid);
2718                 return rc;
2719         }
2720
2721         /*
2722          * Attempt to flush data before changing attributes. We need to do
2723          * this for ATTR_SIZE and ATTR_MTIME.  If the flush of the data
2724          * returns error, store it to report later and continue.
2725          *
2726          * BB: This should be smarter. Why bother flushing pages that
2727          * will be truncated anyway? Also, should we error out here if
2728          * the flush returns error? Do we need to check for ATTR_MTIME_SET flag?
2729          */
2730         if (attrs->ia_valid & (ATTR_MTIME | ATTR_SIZE | ATTR_CTIME)) {
2731                 rc = filemap_write_and_wait(inode->i_mapping);
2732                 if (is_interrupt_error(rc)) {
2733                         rc = -ERESTARTSYS;
2734                         goto cifs_setattr_exit;
2735                 }
2736                 mapping_set_error(inode->i_mapping, rc);
2737         }
2738
2739         rc = 0;
2740
2741         if ((attrs->ia_valid & ATTR_MTIME) &&
2742             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2743                 rc = cifs_get_writable_file(cifsInode, FIND_WR_ANY, &wfile);
2744                 if (!rc) {
2745                         tcon = tlink_tcon(wfile->tlink);
2746                         rc = tcon->ses->server->ops->flush(xid, tcon, &wfile->fid);
2747                         cifsFileInfo_put(wfile);
2748                         if (rc)
2749                                 goto cifs_setattr_exit;
2750                 } else if (rc != -EBADF)
2751                         goto cifs_setattr_exit;
2752                 else
2753                         rc = 0;
2754         }
2755
2756         if (attrs->ia_valid & ATTR_SIZE) {
2757                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2758                 if (rc != 0)
2759                         goto cifs_setattr_exit;
2760         }
2761
2762         if (attrs->ia_valid & ATTR_UID)
2763                 uid = attrs->ia_uid;
2764
2765         if (attrs->ia_valid & ATTR_GID)
2766                 gid = attrs->ia_gid;
2767
2768         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2769             (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2770                 if (uid_valid(uid) || gid_valid(gid)) {
2771                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2772                                                         uid, gid);
2773                         if (rc) {
2774                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2775                                          __func__, rc);
2776                                 goto cifs_setattr_exit;
2777                         }
2778                 }
2779         } else
2780         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2781                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2782
2783         /* skip mode change if it's just for clearing setuid/setgid */
2784         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2785                 attrs->ia_valid &= ~ATTR_MODE;
2786
2787         if (attrs->ia_valid & ATTR_MODE) {
2788                 mode = attrs->ia_mode;
2789                 rc = 0;
2790                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) ||
2791                     (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MODE_FROM_SID)) {
2792                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2793                                                 INVALID_UID, INVALID_GID);
2794                         if (rc) {
2795                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2796                                          __func__, rc);
2797                                 goto cifs_setattr_exit;
2798                         }
2799                 } else
2800                 if (((mode & S_IWUGO) == 0) &&
2801                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2802
2803                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2804
2805                         /* fix up mode if we're not using dynperm */
2806                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2807                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2808                 } else if ((mode & S_IWUGO) &&
2809                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2810
2811                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2812                         /* Attributes of 0 are ignored */
2813                         if (dosattr == 0)
2814                                 dosattr |= ATTR_NORMAL;
2815
2816                         /* reset local inode permissions to normal */
2817                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2818                                 attrs->ia_mode &= ~(S_IALLUGO);
2819                                 if (S_ISDIR(inode->i_mode))
2820                                         attrs->ia_mode |=
2821                                                 cifs_sb->mnt_dir_mode;
2822                                 else
2823                                         attrs->ia_mode |=
2824                                                 cifs_sb->mnt_file_mode;
2825                         }
2826                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2827                         /* ignore mode change - ATTR_READONLY hasn't changed */
2828                         attrs->ia_valid &= ~ATTR_MODE;
2829                 }
2830         }
2831
2832         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2833             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2834                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2835                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2836
2837                 /* Even if error on time set, no sense failing the call if
2838                 the server would set the time to a reasonable value anyway,
2839                 and this check ensures that we are not being called from
2840                 sys_utimes in which case we ought to fail the call back to
2841                 the user when the server rejects the call */
2842                 if ((rc) && (attrs->ia_valid &
2843                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2844                         rc = 0;
2845         }
2846
2847         /* do not need local check to inode_check_ok since the server does
2848            that */
2849         if (rc)
2850                 goto cifs_setattr_exit;
2851
2852         if ((attrs->ia_valid & ATTR_SIZE) &&
2853             attrs->ia_size != i_size_read(inode))
2854                 truncate_setsize(inode, attrs->ia_size);
2855
2856         setattr_copy(inode, attrs);
2857         mark_inode_dirty(inode);
2858
2859 cifs_setattr_exit:
2860         kfree(full_path);
2861         free_xid(xid);
2862         return rc;
2863 }
2864
2865 int
2866 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2867 {
2868         struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
2869         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2870
2871         if (pTcon->unix_ext)
2872                 return cifs_setattr_unix(direntry, attrs);
2873
2874         return cifs_setattr_nounix(direntry, attrs);
2875
2876         /* BB: add cifs_setattr_legacy for really old servers */
2877 }
2878
2879 #if 0
2880 void cifs_delete_inode(struct inode *inode)
2881 {
2882         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2883         /* may have to add back in if and when safe distributed caching of
2884            directories added e.g. via FindNotify */
2885 }
2886 #endif