fs/cifs/inode.c

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