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