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