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