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