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_rename2(struct inode *source_dir, struct dentry *source_dentry,
1631              struct inode *target_dir, struct dentry *target_dentry,
1632              unsigned int flags)
1633 {
1634         char *from_name = NULL;
1635         char *to_name = NULL;
1636         struct cifs_sb_info *cifs_sb;
1637         struct tcon_link *tlink;
1638         struct cifs_tcon *tcon;
1639         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1640         FILE_UNIX_BASIC_INFO *info_buf_target;
1641         unsigned int xid;
1642         int rc, tmprc;
1643
1644         if (flags & ~RENAME_NOREPLACE)
1645                 return -EINVAL;
1646
1647         cifs_sb = CIFS_SB(source_dir->i_sb);
1648         tlink = cifs_sb_tlink(cifs_sb);
1649         if (IS_ERR(tlink))
1650                 return PTR_ERR(tlink);
1651         tcon = tlink_tcon(tlink);
1652
1653         xid = get_xid();
1654
1655         /*
1656          * we already have the rename sem so we do not need to
1657          * grab it again here to protect the path integrity
1658          */
1659         from_name = build_path_from_dentry(source_dentry);
1660         if (from_name == NULL) {
1661                 rc = -ENOMEM;
1662                 goto cifs_rename_exit;
1663         }
1664
1665         to_name = build_path_from_dentry(target_dentry);
1666         if (to_name == NULL) {
1667                 rc = -ENOMEM;
1668                 goto cifs_rename_exit;
1669         }
1670
1671         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1672                             to_name);
1673
1674         /*
1675          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1676          */
1677         if (flags & RENAME_NOREPLACE)
1678                 goto cifs_rename_exit;
1679
1680         if (rc == -EEXIST && tcon->unix_ext) {
1681                 /*
1682                  * Are src and dst hardlinks of same inode? We can only tell
1683                  * with unix extensions enabled.
1684                  */
1685                 info_buf_source =
1686                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1687                                         GFP_KERNEL);
1688                 if (info_buf_source == NULL) {
1689                         rc = -ENOMEM;
1690                         goto cifs_rename_exit;
1691                 }
1692
1693                 info_buf_target = info_buf_source + 1;
1694                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1695                                              info_buf_source,
1696                                              cifs_sb->local_nls,
1697                                              cifs_sb->mnt_cifs_flags &
1698                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1699                 if (tmprc != 0)
1700                         goto unlink_target;
1701
1702                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1703                                              info_buf_target,
1704                                              cifs_sb->local_nls,
1705                                              cifs_sb->mnt_cifs_flags &
1706                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1707
1708                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1709                                    info_buf_target->UniqueId)) {
1710                         /* same file, POSIX says that this is a noop */
1711                         rc = 0;
1712                         goto cifs_rename_exit;
1713                 }
1714         }
1715         /*
1716          * else ... BB we could add the same check for Windows by
1717          * checking the UniqueId via FILE_INTERNAL_INFO
1718          */
1719
1720 unlink_target:
1721         /* Try unlinking the target dentry if it's not negative */
1722         if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1723                 tmprc = cifs_unlink(target_dir, target_dentry);
1724                 if (tmprc)
1725                         goto cifs_rename_exit;
1726                 rc = cifs_do_rename(xid, source_dentry, from_name,
1727                                     target_dentry, to_name);
1728         }
1729
1730 cifs_rename_exit:
1731         kfree(info_buf_source);
1732         kfree(from_name);
1733         kfree(to_name);
1734         free_xid(xid);
1735         cifs_put_tlink(tlink);
1736         return rc;
1737 }
1738
1739 static bool
1740 cifs_inode_needs_reval(struct inode *inode)
1741 {
1742         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1743         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1744
1745         if (CIFS_CACHE_READ(cifs_i))
1746                 return false;
1747
1748         if (!lookupCacheEnabled)
1749                 return true;
1750
1751         if (cifs_i->time == 0)
1752                 return true;
1753
1754         if (!cifs_sb->actimeo)
1755                 return true;
1756
1757         if (!time_in_range(jiffies, cifs_i->time,
1758                                 cifs_i->time + cifs_sb->actimeo))
1759                 return true;
1760
1761         /* hardlinked files w/ noserverino get "special" treatment */
1762         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1763             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1764                 return true;
1765
1766         return false;
1767 }
1768
1769 /*
1770  * Zap the cache. Called when invalid_mapping flag is set.
1771  */
1772 int
1773 cifs_invalidate_mapping(struct inode *inode)
1774 {
1775         int rc = 0;
1776
1777         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1778                 rc = invalidate_inode_pages2(inode->i_mapping);
1779                 if (rc)
1780                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1781                                  __func__, inode);
1782         }
1783
1784         cifs_fscache_reset_inode_cookie(inode);
1785         return rc;
1786 }
1787
1788 /**
1789  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1790  * @word: long word containing the bit lock
1791  */
1792 static int
1793 cifs_wait_bit_killable(struct wait_bit_key *key)
1794 {
1795         if (fatal_signal_pending(current))
1796                 return -ERESTARTSYS;
1797         freezable_schedule_unsafe();
1798         return 0;
1799 }
1800
1801 int
1802 cifs_revalidate_mapping(struct inode *inode)
1803 {
1804         int rc;
1805         unsigned long *flags = &CIFS_I(inode)->flags;
1806
1807         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1808                                      TASK_KILLABLE);
1809         if (rc)
1810                 return rc;
1811
1812         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1813                 rc = cifs_invalidate_mapping(inode);
1814                 if (rc)
1815                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1816         }
1817
1818         clear_bit_unlock(CIFS_INO_LOCK, flags);
1819         smp_mb__after_atomic();
1820         wake_up_bit(flags, CIFS_INO_LOCK);
1821
1822         return rc;
1823 }
1824
1825 int
1826 cifs_zap_mapping(struct inode *inode)
1827 {
1828         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1829         return cifs_revalidate_mapping(inode);
1830 }
1831
1832 int cifs_revalidate_file_attr(struct file *filp)
1833 {
1834         int rc = 0;
1835         struct inode *inode = file_inode(filp);
1836         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1837
1838         if (!cifs_inode_needs_reval(inode))
1839                 return rc;
1840
1841         if (tlink_tcon(cfile->tlink)->unix_ext)
1842                 rc = cifs_get_file_info_unix(filp);
1843         else
1844                 rc = cifs_get_file_info(filp);
1845
1846         return rc;
1847 }
1848
1849 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1850 {
1851         unsigned int xid;
1852         int rc = 0;
1853         struct inode *inode = dentry->d_inode;
1854         struct super_block *sb = dentry->d_sb;
1855         char *full_path = NULL;
1856
1857         if (inode == NULL)
1858                 return -ENOENT;
1859
1860         if (!cifs_inode_needs_reval(inode))
1861                 return rc;
1862
1863         xid = get_xid();
1864
1865         /* can not safely grab the rename sem here if rename calls revalidate
1866            since that would deadlock */
1867         full_path = build_path_from_dentry(dentry);
1868         if (full_path == NULL) {
1869                 rc = -ENOMEM;
1870                 goto out;
1871         }
1872
1873         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1874                  full_path, inode, inode->i_count.counter,
1875                  dentry, dentry->d_time, jiffies);
1876
1877         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1878                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1879         else
1880                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1881                                          xid, NULL);
1882
1883 out:
1884         kfree(full_path);
1885         free_xid(xid);
1886         return rc;
1887 }
1888
1889 int cifs_revalidate_file(struct file *filp)
1890 {
1891         int rc;
1892         struct inode *inode = file_inode(filp);
1893
1894         rc = cifs_revalidate_file_attr(filp);
1895         if (rc)
1896                 return rc;
1897
1898         return cifs_revalidate_mapping(inode);
1899 }
1900
1901 /* revalidate a dentry's inode attributes */
1902 int cifs_revalidate_dentry(struct dentry *dentry)
1903 {
1904         int rc;
1905         struct inode *inode = dentry->d_inode;
1906
1907         rc = cifs_revalidate_dentry_attr(dentry);
1908         if (rc)
1909                 return rc;
1910
1911         return cifs_revalidate_mapping(inode);
1912 }
1913
1914 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1915                  struct kstat *stat)
1916 {
1917         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1918         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1919         struct inode *inode = dentry->d_inode;
1920         int rc;
1921
1922         /*
1923          * We need to be sure that all dirty pages are written and the server
1924          * has actual ctime, mtime and file length.
1925          */
1926         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1927             inode->i_mapping->nrpages != 0) {
1928                 rc = filemap_fdatawait(inode->i_mapping);
1929                 if (rc) {
1930                         mapping_set_error(inode->i_mapping, rc);
1931                         return rc;
1932                 }
1933         }
1934
1935         rc = cifs_revalidate_dentry_attr(dentry);
1936         if (rc)
1937                 return rc;
1938
1939         generic_fillattr(inode, stat);
1940         stat->blksize = CIFS_MAX_MSGSIZE;
1941         stat->ino = CIFS_I(inode)->uniqueid;
1942
1943         /*
1944          * If on a multiuser mount without unix extensions or cifsacl being
1945          * enabled, and the admin hasn't overridden them, set the ownership
1946          * to the fsuid/fsgid of the current process.
1947          */
1948         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1949             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1950             !tcon->unix_ext) {
1951                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1952                         stat->uid = current_fsuid();
1953                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1954                         stat->gid = current_fsgid();
1955         }
1956         return rc;
1957 }
1958
1959 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1960 {
1961         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1962         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1963         struct page *page;
1964         int rc = 0;
1965
1966         page = grab_cache_page(mapping, index);
1967         if (!page)
1968                 return -ENOMEM;
1969
1970         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1971         unlock_page(page);
1972         page_cache_release(page);
1973         return rc;
1974 }
1975
1976 static void cifs_setsize(struct inode *inode, loff_t offset)
1977 {
1978         spin_lock(&inode->i_lock);
1979         i_size_write(inode, offset);
1980         spin_unlock(&inode->i_lock);
1981
1982         truncate_pagecache(inode, offset);
1983 }
1984
1985 static int
1986 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1987                    unsigned int xid, char *full_path)
1988 {
1989         int rc;
1990         struct cifsFileInfo *open_file;
1991         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1992         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1993         struct tcon_link *tlink = NULL;
1994         struct cifs_tcon *tcon = NULL;
1995         struct TCP_Server_Info *server;
1996         struct cifs_io_parms io_parms;
1997
1998         /*
1999          * To avoid spurious oplock breaks from server, in the case of
2000          * inodes that we already have open, avoid doing path based
2001          * setting of file size if we can do it by handle.
2002          * This keeps our caching token (oplock) and avoids timeouts
2003          * when the local oplock break takes longer to flush
2004          * writebehind data than the SMB timeout for the SetPathInfo
2005          * request would allow
2006          */
2007         open_file = find_writable_file(cifsInode, true);
2008         if (open_file) {
2009                 tcon = tlink_tcon(open_file->tlink);
2010                 server = tcon->ses->server;
2011                 if (server->ops->set_file_size)
2012                         rc = server->ops->set_file_size(xid, tcon, open_file,
2013                                                         attrs->ia_size, false);
2014                 else
2015                         rc = -ENOSYS;
2016                 cifsFileInfo_put(open_file);
2017                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2018                 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2019                         unsigned int bytes_written;
2020
2021                         io_parms.netfid = open_file->fid.netfid;
2022                         io_parms.pid = open_file->pid;
2023                         io_parms.tcon = tcon;
2024                         io_parms.offset = 0;
2025                         io_parms.length = attrs->ia_size;
2026                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
2027                                           NULL, NULL, 1);
2028                         cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
2029                 }
2030         } else
2031                 rc = -EINVAL;
2032
2033         if (!rc)
2034                 goto set_size_out;
2035
2036         if (tcon == NULL) {
2037                 tlink = cifs_sb_tlink(cifs_sb);
2038                 if (IS_ERR(tlink))
2039                         return PTR_ERR(tlink);
2040                 tcon = tlink_tcon(tlink);
2041                 server = tcon->ses->server;
2042         }
2043
2044         /*
2045          * Set file size by pathname rather than by handle either because no
2046          * valid, writeable file handle for it was found or because there was
2047          * an error setting it by handle.
2048          */
2049         if (server->ops->set_path_size)
2050                 rc = server->ops->set_path_size(xid, tcon, full_path,
2051                                                 attrs->ia_size, cifs_sb, false);
2052         else
2053                 rc = -ENOSYS;
2054         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2055         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
2056                 __u16 netfid;
2057                 int oplock = 0;
2058
2059                 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
2060                                    GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
2061                                    &oplock, NULL, cifs_sb->local_nls,
2062                                    cifs_sb->mnt_cifs_flags &
2063                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2064                 if (rc == 0) {
2065                         unsigned int bytes_written;
2066
2067                         io_parms.netfid = netfid;
2068                         io_parms.pid = current->tgid;
2069                         io_parms.tcon = tcon;
2070                         io_parms.offset = 0;
2071                         io_parms.length = attrs->ia_size;
2072                         rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
2073                                           NULL,  1);
2074                         cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
2075                         CIFSSMBClose(xid, tcon, netfid);
2076                 }
2077         }
2078         if (tlink)
2079                 cifs_put_tlink(tlink);
2080
2081 set_size_out:
2082         if (rc == 0) {
2083                 cifsInode->server_eof = attrs->ia_size;
2084                 cifs_setsize(inode, attrs->ia_size);
2085                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2086         }
2087
2088         return rc;
2089 }
2090
2091 static int
2092 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2093 {
2094         int rc;
2095         unsigned int xid;
2096         char *full_path = NULL;
2097         struct inode *inode = direntry->d_inode;
2098         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2099         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2100         struct tcon_link *tlink;
2101         struct cifs_tcon *pTcon;
2102         struct cifs_unix_set_info_args *args = NULL;
2103         struct cifsFileInfo *open_file;
2104
2105         cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2106                  direntry->d_name.name, attrs->ia_valid);
2107
2108         xid = get_xid();
2109
2110         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2111                 attrs->ia_valid |= ATTR_FORCE;
2112
2113         rc = inode_change_ok(inode, attrs);
2114         if (rc < 0)
2115                 goto out;
2116
2117         full_path = build_path_from_dentry(direntry);
2118         if (full_path == NULL) {
2119                 rc = -ENOMEM;
2120                 goto out;
2121         }
2122
2123         /*
2124          * Attempt to flush data before changing attributes. We need to do
2125          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2126          * ownership or mode then we may also need to do this. Here, we take
2127          * the safe way out and just do the flush on all setattr requests. If
2128          * the flush returns error, store it to report later and continue.
2129          *
2130          * BB: This should be smarter. Why bother flushing pages that
2131          * will be truncated anyway? Also, should we error out here if
2132          * the flush returns error?
2133          */
2134         rc = filemap_write_and_wait(inode->i_mapping);
2135         mapping_set_error(inode->i_mapping, rc);
2136         rc = 0;
2137
2138         if (attrs->ia_valid & ATTR_SIZE) {
2139                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2140                 if (rc != 0)
2141                         goto out;
2142         }
2143
2144         /* skip mode change if it's just for clearing setuid/setgid */
2145         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2146                 attrs->ia_valid &= ~ATTR_MODE;
2147
2148         args = kmalloc(sizeof(*args), GFP_KERNEL);
2149         if (args == NULL) {
2150                 rc = -ENOMEM;
2151                 goto out;
2152         }
2153
2154         /* set up the struct */
2155         if (attrs->ia_valid & ATTR_MODE)
2156                 args->mode = attrs->ia_mode;
2157         else
2158                 args->mode = NO_CHANGE_64;
2159
2160         if (attrs->ia_valid & ATTR_UID)
2161                 args->uid = attrs->ia_uid;
2162         else
2163                 args->uid = INVALID_UID; /* no change */
2164
2165         if (attrs->ia_valid & ATTR_GID)
2166                 args->gid = attrs->ia_gid;
2167         else
2168                 args->gid = INVALID_GID; /* no change */
2169
2170         if (attrs->ia_valid & ATTR_ATIME)
2171                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2172         else
2173                 args->atime = NO_CHANGE_64;
2174
2175         if (attrs->ia_valid & ATTR_MTIME)
2176                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2177         else
2178                 args->mtime = NO_CHANGE_64;
2179
2180         if (attrs->ia_valid & ATTR_CTIME)
2181                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2182         else
2183                 args->ctime = NO_CHANGE_64;
2184
2185         args->device = 0;
2186         open_file = find_writable_file(cifsInode, true);
2187         if (open_file) {
2188                 u16 nfid = open_file->fid.netfid;
2189                 u32 npid = open_file->pid;
2190                 pTcon = tlink_tcon(open_file->tlink);
2191                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2192                 cifsFileInfo_put(open_file);
2193         } else {
2194                 tlink = cifs_sb_tlink(cifs_sb);
2195                 if (IS_ERR(tlink)) {
2196                         rc = PTR_ERR(tlink);
2197                         goto out;
2198                 }
2199                 pTcon = tlink_tcon(tlink);
2200                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2201                                     cifs_sb->local_nls,
2202                                     cifs_sb->mnt_cifs_flags &
2203                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
2204                 cifs_put_tlink(tlink);
2205         }
2206
2207         if (rc)
2208                 goto out;
2209
2210         if ((attrs->ia_valid & ATTR_SIZE) &&
2211             attrs->ia_size != i_size_read(inode))
2212                 truncate_setsize(inode, attrs->ia_size);
2213
2214         setattr_copy(inode, attrs);
2215         mark_inode_dirty(inode);
2216
2217         /* force revalidate when any of these times are set since some
2218            of the fs types (eg ext3, fat) do not have fine enough
2219            time granularity to match protocol, and we do not have a
2220            a way (yet) to query the server fs's time granularity (and
2221            whether it rounds times down).
2222         */
2223         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2224                 cifsInode->time = 0;
2225 out:
2226         kfree(args);
2227         kfree(full_path);
2228         free_xid(xid);
2229         return rc;
2230 }
2231
2232 static int
2233 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2234 {
2235         unsigned int xid;
2236         kuid_t uid = INVALID_UID;
2237         kgid_t gid = INVALID_GID;
2238         struct inode *inode = direntry->d_inode;
2239         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2240         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2241         char *full_path = NULL;
2242         int rc = -EACCES;
2243         __u32 dosattr = 0;
2244         __u64 mode = NO_CHANGE_64;
2245
2246         xid = get_xid();
2247
2248         cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2249                  direntry->d_name.name, attrs->ia_valid);
2250
2251         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2252                 attrs->ia_valid |= ATTR_FORCE;
2253
2254         rc = inode_change_ok(inode, attrs);
2255         if (rc < 0) {
2256                 free_xid(xid);
2257                 return rc;
2258         }
2259
2260         full_path = build_path_from_dentry(direntry);
2261         if (full_path == NULL) {
2262                 rc = -ENOMEM;
2263                 free_xid(xid);
2264                 return rc;
2265         }
2266
2267         /*
2268          * Attempt to flush data before changing attributes. We need to do
2269          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2270          * ownership or mode then we may also need to do this. Here, we take
2271          * the safe way out and just do the flush on all setattr requests. If
2272          * the flush returns error, store it to report later and continue.
2273          *
2274          * BB: This should be smarter. Why bother flushing pages that
2275          * will be truncated anyway? Also, should we error out here if
2276          * the flush returns error?
2277          */
2278         rc = filemap_write_and_wait(inode->i_mapping);
2279         mapping_set_error(inode->i_mapping, rc);
2280         rc = 0;
2281
2282         if (attrs->ia_valid & ATTR_SIZE) {
2283                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2284                 if (rc != 0)
2285                         goto cifs_setattr_exit;
2286         }
2287
2288         if (attrs->ia_valid & ATTR_UID)
2289                 uid = attrs->ia_uid;
2290
2291         if (attrs->ia_valid & ATTR_GID)
2292                 gid = attrs->ia_gid;
2293
2294 #ifdef CONFIG_CIFS_ACL
2295         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2296                 if (uid_valid(uid) || gid_valid(gid)) {
2297                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2298                                                         uid, gid);
2299                         if (rc) {
2300                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2301                                          __func__, rc);
2302                                 goto cifs_setattr_exit;
2303                         }
2304                 }
2305         } else
2306 #endif /* CONFIG_CIFS_ACL */
2307         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2308                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2309
2310         /* skip mode change if it's just for clearing setuid/setgid */
2311         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2312                 attrs->ia_valid &= ~ATTR_MODE;
2313
2314         if (attrs->ia_valid & ATTR_MODE) {
2315                 mode = attrs->ia_mode;
2316                 rc = 0;
2317 #ifdef CONFIG_CIFS_ACL
2318                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2319                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2320                                                 INVALID_UID, INVALID_GID);
2321                         if (rc) {
2322                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2323                                          __func__, rc);
2324                                 goto cifs_setattr_exit;
2325                         }
2326                 } else
2327 #endif /* CONFIG_CIFS_ACL */
2328                 if (((mode & S_IWUGO) == 0) &&
2329                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2330
2331                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2332
2333                         /* fix up mode if we're not using dynperm */
2334                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2335                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2336                 } else if ((mode & S_IWUGO) &&
2337                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2338
2339                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2340                         /* Attributes of 0 are ignored */
2341                         if (dosattr == 0)
2342                                 dosattr |= ATTR_NORMAL;
2343
2344                         /* reset local inode permissions to normal */
2345                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2346                                 attrs->ia_mode &= ~(S_IALLUGO);
2347                                 if (S_ISDIR(inode->i_mode))
2348                                         attrs->ia_mode |=
2349                                                 cifs_sb->mnt_dir_mode;
2350                                 else
2351                                         attrs->ia_mode |=
2352                                                 cifs_sb->mnt_file_mode;
2353                         }
2354                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2355                         /* ignore mode change - ATTR_READONLY hasn't changed */
2356                         attrs->ia_valid &= ~ATTR_MODE;
2357                 }
2358         }
2359
2360         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2361             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2362                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2363                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2364
2365                 /* Even if error on time set, no sense failing the call if
2366                 the server would set the time to a reasonable value anyway,
2367                 and this check ensures that we are not being called from
2368                 sys_utimes in which case we ought to fail the call back to
2369                 the user when the server rejects the call */
2370                 if ((rc) && (attrs->ia_valid &
2371                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2372                         rc = 0;
2373         }
2374
2375         /* do not need local check to inode_check_ok since the server does
2376            that */
2377         if (rc)
2378                 goto cifs_setattr_exit;
2379
2380         if ((attrs->ia_valid & ATTR_SIZE) &&
2381             attrs->ia_size != i_size_read(inode))
2382                 truncate_setsize(inode, attrs->ia_size);
2383
2384         setattr_copy(inode, attrs);
2385         mark_inode_dirty(inode);
2386
2387 cifs_setattr_exit:
2388         kfree(full_path);
2389         free_xid(xid);
2390         return rc;
2391 }
2392
2393 int
2394 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2395 {
2396         struct inode *inode = direntry->d_inode;
2397         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2398         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2399
2400         if (pTcon->unix_ext)
2401                 return cifs_setattr_unix(direntry, attrs);
2402
2403         return cifs_setattr_nounix(direntry, attrs);
2404
2405         /* BB: add cifs_setattr_legacy for really old servers */
2406 }
2407
2408 #if 0
2409 void cifs_delete_inode(struct inode *inode)
2410 {
2411         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2412         /* may have to add back in if and when safe distributed caching of
2413            directories added e.g. via FindNotify */
2414 }
2415 #endif