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