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