fs/cifs/inode.c

   1 /*
   2  *   fs/cifs/inode.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2007
   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/pagemap.h>
  24 #include <asm/div64.h>
  25 #include "cifsfs.h"
  26 #include "cifspdu.h"
  27 #include "cifsglob.h"
  28 #include "cifsproto.h"
  29 #include "cifs_debug.h"
  30 #include "cifs_fs_sb.h"
  31
  32
  33 static void cifs_set_ops(struct inode *inode)
  34 {
  35         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  36
  37         switch (inode->i_mode & S_IFMT) {
  38         case S_IFREG:
  39                 inode->i_op = &cifs_file_inode_ops;
  40                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
  41                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  42                                 inode->i_fop = &cifs_file_direct_nobrl_ops;
  43                         else
  44                                 inode->i_fop = &cifs_file_direct_ops;
  45                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
  46                         inode->i_fop = &cifs_file_nobrl_ops;
  47                 else { /* not direct, send byte range locks */
  48                         inode->i_fop = &cifs_file_ops;
  49                 }
  50
  51
  52                 /* check if server can support readpages */
  53                 if (cifs_sb->tcon->ses->server->maxBuf <
  54                                 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
  55                         inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
  56                 else
  57                         inode->i_data.a_ops = &cifs_addr_ops;
  58                 break;
  59         case S_IFDIR:
  60                 inode->i_op = &cifs_dir_inode_ops;
  61                 inode->i_fop = &cifs_dir_ops;
  62                 break;
  63         case S_IFLNK:
  64                 inode->i_op = &cifs_symlink_inode_ops;
  65                 break;
  66         default:
  67                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
  68                 break;
  69         }
  70 }
  71
  72 static void cifs_unix_info_to_inode(struct inode *inode,
  73                 FILE_UNIX_BASIC_INFO *info, int force_uid_gid)
  74 {
  75         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
  76         struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
  77         __u64 num_of_bytes = le64_to_cpu(info->NumOfBytes);
  78         __u64 end_of_file = le64_to_cpu(info->EndOfFile);
  79
  80         inode->i_atime = cifs_NTtimeToUnix(le64_to_cpu(info->LastAccessTime));
  81         inode->i_mtime =
  82                 cifs_NTtimeToUnix(le64_to_cpu(info->LastModificationTime));
  83         inode->i_ctime = cifs_NTtimeToUnix(le64_to_cpu(info->LastStatusChange));
  84         inode->i_mode = le64_to_cpu(info->Permissions);
  85
  86         /*
  87          * Since we set the inode type below we need to mask off
  88          * to avoid strange results if bits set above.
  89          */
  90         inode->i_mode &= ~S_IFMT;
  91         switch (le32_to_cpu(info->Type)) {
  92         case UNIX_FILE:
  93                 inode->i_mode |= S_IFREG;
  94                 break;
  95         case UNIX_SYMLINK:
  96                 inode->i_mode |= S_IFLNK;
  97                 break;
  98         case UNIX_DIR:
  99                 inode->i_mode |= S_IFDIR;
 100                 break;
 101         case UNIX_CHARDEV:
 102                 inode->i_mode |= S_IFCHR;
 103                 inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 104                                       le64_to_cpu(info->DevMinor) & MINORMASK);
 105                 break;
 106         case UNIX_BLOCKDEV:
 107                 inode->i_mode |= S_IFBLK;
 108                 inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
 109                                       le64_to_cpu(info->DevMinor) & MINORMASK);
 110                 break;
 111         case UNIX_FIFO:
 112                 inode->i_mode |= S_IFIFO;
 113                 break;
 114         case UNIX_SOCKET:
 115                 inode->i_mode |= S_IFSOCK;
 116                 break;
 117         default:
 118                 /* safest to call it a file if we do not know */
 119                 inode->i_mode |= S_IFREG;
 120                 cFYI(1, ("unknown type %d", le32_to_cpu(info->Type)));
 121                 break;
 122         }
 123
 124         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) &&
 125             !force_uid_gid)
 126                 inode->i_uid = cifs_sb->mnt_uid;
 127         else
 128                 inode->i_uid = le64_to_cpu(info->Uid);
 129
 130         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) &&
 131             !force_uid_gid)
 132                 inode->i_gid = cifs_sb->mnt_gid;
 133         else
 134                 inode->i_gid = le64_to_cpu(info->Gid);
 135
 136         inode->i_nlink = le64_to_cpu(info->Nlinks);
 137
 138         spin_lock(&inode->i_lock);
 139         if (is_size_safe_to_change(cifsInfo, end_of_file)) {
 140                 /*
 141                  * We can not safely change the file size here if the client
 142                  * is writing to it due to potential races.
 143                  */
 144                 i_size_write(inode, end_of_file);
 145
 146                 /*
 147                  * i_blocks is not related to (i_size / i_blksize),
 148                  * but instead 512 byte (2**9) size is required for
 149                  * calculating num blocks.
 150                  */
 151                 inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
 152         }
 153         spin_unlock(&inode->i_lock);
 154 }
 155
 156 int cifs_get_inode_info_unix(struct inode **pinode,
 157         const unsigned char *search_path, struct super_block *sb, int xid)
 158 {
 159         int rc = 0;
 160         FILE_UNIX_BASIC_INFO findData;
 161         struct cifsTconInfo *pTcon;
 162         struct inode *inode;
 163         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 164         char *tmp_path;
 165
 166         pTcon = cifs_sb->tcon;
 167         cFYI(1, ("Getting info on %s", search_path));
 168         /* could have done a find first instead but this returns more info */
 169         rc = CIFSSMBUnixQPathInfo(xid, pTcon, search_path, &findData,
 170                                   cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 171                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 172 /*      dump_mem("\nUnixQPathInfo return data", &findData,
 173                  sizeof(findData)); */
 174         if (rc) {
 175                 if (rc == -EREMOTE) {
 176                         tmp_path =
 177                             kmalloc(strnlen(pTcon->treeName,
 178                                             MAX_TREE_SIZE + 1) +
 179                                     strnlen(search_path, MAX_PATHCONF) + 1,
 180                                     GFP_KERNEL);
 181                         if (tmp_path == NULL)
 182                                 return -ENOMEM;
 183
 184                         /* have to skip first of the double backslash of
 185                            UNC name */
 186                         strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
 187                         strncat(tmp_path, search_path, MAX_PATHCONF);
 188                         rc = connect_to_dfs_path(xid, pTcon->ses,
 189                                                  /* treename + */ tmp_path,
 190                                                  cifs_sb->local_nls,
 191                                                  cifs_sb->mnt_cifs_flags &
 192                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 193                         kfree(tmp_path);
 194
 195                         /* BB fix up inode etc. */
 196                 } else if (rc) {
 197                         return rc;
 198                 }
 199         } else {
 200                 struct cifsInodeInfo *cifsInfo;
 201                 __u64 num_of_bytes = le64_to_cpu(findData.NumOfBytes);
 202                 __u64 end_of_file = le64_to_cpu(findData.EndOfFile);
 203
 204                 /* get new inode */
 205                 if (*pinode == NULL) {
 206                         *pinode = new_inode(sb);
 207                         if (*pinode == NULL)
 208                                 return -ENOMEM;
 209                         /* Is an i_ino of zero legal? */
 210                         /* Are there sanity checks we can use to ensure that
 211                            the server is really filling in that field? */
 212                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 213                                 (*pinode)->i_ino =
 214                                         (unsigned long)findData.UniqueId;
 215                         } /* note ino incremented to unique num in new_inode */
 216                         if (sb->s_flags & MS_NOATIME)
 217                                 (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
 218
 219                         insert_inode_hash(*pinode);
 220                 }
 221
 222                 inode = *pinode;
 223                 cifsInfo = CIFS_I(inode);
 224
 225                 cFYI(1, ("Old time %ld", cifsInfo->time));
 226                 cifsInfo->time = jiffies;
 227                 cFYI(1, ("New time %ld", cifsInfo->time));
 228                 /* this is ok to set on every inode revalidate */
 229                 atomic_set(&cifsInfo->inUse, 1);
 230
 231                 cifs_unix_info_to_inode(inode, &findData, 0);
 232
 233
 234                 if (num_of_bytes < end_of_file)
 235                         cFYI(1, ("allocation size less than end of file"));
 236                 cFYI(1, ("Size %ld and blocks %llu",
 237                         (unsigned long) inode->i_size,
 238                         (unsigned long long)inode->i_blocks));
 239
 240                 cifs_set_ops(inode);
 241         }
 242         return rc;
 243 }
 244
 245 static int decode_sfu_inode(struct inode *inode, __u64 size,
 246                             const unsigned char *path,
 247                             struct cifs_sb_info *cifs_sb, int xid)
 248 {
 249         int rc;
 250         int oplock = FALSE;
 251         __u16 netfid;
 252         struct cifsTconInfo *pTcon = cifs_sb->tcon;
 253         char buf[24];
 254         unsigned int bytes_read;
 255         char *pbuf;
 256
 257         pbuf = buf;
 258
 259         if (size == 0) {
 260                 inode->i_mode |= S_IFIFO;
 261                 return 0;
 262         } else if (size < 8) {
 263                 return -EINVAL;  /* EOPNOTSUPP? */
 264         }
 265
 266         rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
 267                          CREATE_NOT_DIR, &netfid, &oplock, NULL,
 268                          cifs_sb->local_nls,
 269                          cifs_sb->mnt_cifs_flags &
 270                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 271         if (rc == 0) {
 272                 int buf_type = CIFS_NO_BUFFER;
 273                         /* Read header */
 274                 rc = CIFSSMBRead(xid, pTcon,
 275                                  netfid,
 276                                  24 /* length */, 0 /* offset */,
 277                                  &bytes_read, &pbuf, &buf_type);
 278                 if ((rc == 0) && (bytes_read >= 8)) {
 279                         if (memcmp("IntxBLK", pbuf, 8) == 0) {
 280                                 cFYI(1, ("Block device"));
 281                                 inode->i_mode |= S_IFBLK;
 282                                 if (bytes_read == 24) {
 283                                         /* we have enough to decode dev num */
 284                                         __u64 mjr; /* major */
 285                                         __u64 mnr; /* minor */
 286                                         mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 287                                         mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 288                                         inode->i_rdev = MKDEV(mjr, mnr);
 289                                 }
 290                         } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
 291                                 cFYI(1, ("Char device"));
 292                                 inode->i_mode |= S_IFCHR;
 293                                 if (bytes_read == 24) {
 294                                         /* we have enough to decode dev num */
 295                                         __u64 mjr; /* major */
 296                                         __u64 mnr; /* minor */
 297                                         mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
 298                                         mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
 299                                         inode->i_rdev = MKDEV(mjr, mnr);
 300                                 }
 301                         } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
 302                                 cFYI(1, ("Symlink"));
 303                                 inode->i_mode |= S_IFLNK;
 304                         } else {
 305                                 inode->i_mode |= S_IFREG; /* file? */
 306                                 rc = -EOPNOTSUPP;
 307                         }
 308                 } else {
 309                         inode->i_mode |= S_IFREG; /* then it is a file */
 310                         rc = -EOPNOTSUPP; /* or some unknown SFU type */
 311                 }
 312                 CIFSSMBClose(xid, pTcon, netfid);
 313         }
 314         return rc;
 315 }
 316
 317 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
 318
 319 static int get_sfu_mode(struct inode *inode,
 320                         const unsigned char *path,
 321                         struct cifs_sb_info *cifs_sb, int xid)
 322 {
 323 #ifdef CONFIG_CIFS_XATTR
 324         ssize_t rc;
 325         char ea_value[4];
 326         __u32 mode;
 327
 328         rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
 329                         ea_value, 4 /* size of buf */, cifs_sb->local_nls,
 330                 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 331         if (rc < 0)
 332                 return (int)rc;
 333         else if (rc > 3) {
 334                 mode = le32_to_cpu(*((__le32 *)ea_value));
 335                 inode->i_mode &= ~SFBITS_MASK;
 336                 cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
 337                 inode->i_mode = (mode &  SFBITS_MASK) | inode->i_mode;
 338                 cFYI(1, ("special mode bits 0%o", mode));
 339                 return 0;
 340         } else {
 341                 return 0;
 342         }
 343 #else
 344         return -EOPNOTSUPP;
 345 #endif
 346 }
 347
 348 int cifs_get_inode_info(struct inode **pinode,
 349         const unsigned char *search_path, FILE_ALL_INFO *pfindData,
 350         struct super_block *sb, int xid)
 351 {
 352         int rc = 0;
 353         struct cifsTconInfo *pTcon;
 354         struct inode *inode;
 355         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 356         char *tmp_path;
 357         char *buf = NULL;
 358         int adjustTZ = FALSE;
 359
 360         pTcon = cifs_sb->tcon;
 361         cFYI(1, ("Getting info on %s", search_path));
 362
 363         if ((pfindData == NULL) && (*pinode != NULL)) {
 364                 if (CIFS_I(*pinode)->clientCanCacheRead) {
 365                         cFYI(1, ("No need to revalidate cached inode sizes"));
 366                         return rc;
 367                 }
 368         }
 369
 370         /* if file info not passed in then get it from server */
 371         if (pfindData == NULL) {
 372                 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 373                 if (buf == NULL)
 374                         return -ENOMEM;
 375                 pfindData = (FILE_ALL_INFO *)buf;
 376                 /* could do find first instead but this returns more info */
 377                 rc = CIFSSMBQPathInfo(xid, pTcon, search_path, pfindData,
 378                               0 /* not legacy */,
 379                               cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 380                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 381                 /* BB optimize code so we do not make the above call
 382                 when server claims no NT SMB support and the above call
 383                 failed at least once - set flag in tcon or mount */
 384                 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
 385                         rc = SMBQueryInformation(xid, pTcon, search_path,
 386                                         pfindData, cifs_sb->local_nls,
 387                                         cifs_sb->mnt_cifs_flags &
 388                                           CIFS_MOUNT_MAP_SPECIAL_CHR);
 389                         adjustTZ = TRUE;
 390                 }
 391         }
 392         /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
 393         if (rc) {
 394                 if (rc == -EREMOTE) {
 395                         tmp_path =
 396                             kmalloc(strnlen
 397                                     (pTcon->treeName,
 398                                      MAX_TREE_SIZE + 1) +
 399                                     strnlen(search_path, MAX_PATHCONF) + 1,
 400                                     GFP_KERNEL);
 401                         if (tmp_path == NULL) {
 402                                 kfree(buf);
 403                                 return -ENOMEM;
 404                         }
 405
 406                         strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
 407                         strncat(tmp_path, search_path, MAX_PATHCONF);
 408                         rc = connect_to_dfs_path(xid, pTcon->ses,
 409                                                  /* treename + */ tmp_path,
 410                                                  cifs_sb->local_nls,
 411                                                  cifs_sb->mnt_cifs_flags &
 412                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
 413                         kfree(tmp_path);
 414                         /* BB fix up inode etc. */
 415                 } else if (rc) {
 416                         kfree(buf);
 417                         return rc;
 418                 }
 419         } else {
 420                 struct cifsInodeInfo *cifsInfo;
 421                 __u32 attr = le32_to_cpu(pfindData->Attributes);
 422
 423                 /* get new inode */
 424                 if (*pinode == NULL) {
 425                         *pinode = new_inode(sb);
 426                         if (*pinode == NULL) {
 427                                 kfree(buf);
 428                                 return -ENOMEM;
 429                         }
 430                         /* Is an i_ino of zero legal? Can we use that to check
 431                            if the server supports returning inode numbers?  Are
 432                            there other sanity checks we can use to ensure that
 433                            the server is really filling in that field? */
 434
 435                         /* We can not use the IndexNumber field by default from
 436                            Windows or Samba (in ALL_INFO buf) but we can request
 437                            it explicitly.  It may not be unique presumably if
 438                            the server has multiple devices mounted under one
 439                            share */
 440
 441                         /* There may be higher info levels that work but are
 442                            there Windows server or network appliances for which
 443                            IndexNumber field is not guaranteed unique? */
 444
 445                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 446                                 int rc1 = 0;
 447                                 __u64 inode_num;
 448
 449                                 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
 450                                         search_path, &inode_num,
 451                                         cifs_sb->local_nls,
 452                                         cifs_sb->mnt_cifs_flags &
 453                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 454                                 if (rc1) {
 455                                         cFYI(1, ("GetSrvInodeNum rc %d", rc1));
 456                                         /* BB EOPNOSUPP disable SERVER_INUM? */
 457                                 } else /* do we need cast or hash to ino? */
 458                                         (*pinode)->i_ino = inode_num;
 459                         } /* else ino incremented to unique num in new_inode*/
 460                         if (sb->s_flags & MS_NOATIME)
 461                                 (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
 462                         insert_inode_hash(*pinode);
 463                 }
 464                 inode = *pinode;
 465                 cifsInfo = CIFS_I(inode);
 466                 cifsInfo->cifsAttrs = attr;
 467                 cFYI(1, ("Old time %ld", cifsInfo->time));
 468                 cifsInfo->time = jiffies;
 469                 cFYI(1, ("New time %ld", cifsInfo->time));
 470
 471                 /* blksize needs to be multiple of two. So safer to default to
 472                 blksize and blkbits set in superblock so 2**blkbits and blksize
 473                 will match rather than setting to:
 474                 (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
 475
 476                 /* Linux can not store file creation time so ignore it */
 477                 if (pfindData->LastAccessTime)
 478                         inode->i_atime = cifs_NTtimeToUnix
 479                                 (le64_to_cpu(pfindData->LastAccessTime));
 480                 else /* do not need to use current_fs_time - time not stored */
 481                         inode->i_atime = CURRENT_TIME;
 482                 inode->i_mtime =
 483                     cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
 484                 inode->i_ctime =
 485                     cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
 486                 cFYI(0, ("Attributes came in as 0x%x", attr));
 487                 if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
 488                         inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
 489                         inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
 490                 }
 491
 492                 /* set default mode. will override for dirs below */
 493                 if (atomic_read(&cifsInfo->inUse) == 0)
 494                         /* new inode, can safely set these fields */
 495                         inode->i_mode = cifs_sb->mnt_file_mode;
 496                 else /* since we set the inode type below we need to mask off
 497                      to avoid strange results if type changes and both
 498                      get orred in */
 499                         inode->i_mode &= ~S_IFMT;
 500 /*              if (attr & ATTR_REPARSE)  */
 501                 /* We no longer handle these as symlinks because we could not
 502                    follow them due to the absolute path with drive letter */
 503                 if (attr & ATTR_DIRECTORY) {
 504                 /* override default perms since we do not do byte range locking
 505                    on dirs */
 506                         inode->i_mode = cifs_sb->mnt_dir_mode;
 507                         inode->i_mode |= S_IFDIR;
 508                 } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
 509                            (cifsInfo->cifsAttrs & ATTR_SYSTEM) &&
 510                            /* No need to le64 convert size of zero */
 511                            (pfindData->EndOfFile == 0)) {
 512                         inode->i_mode = cifs_sb->mnt_file_mode;
 513                         inode->i_mode |= S_IFIFO;
 514 /* BB Finish for SFU style symlinks and devices */
 515                 } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
 516                            (cifsInfo->cifsAttrs & ATTR_SYSTEM)) {
 517                         if (decode_sfu_inode(inode,
 518                                          le64_to_cpu(pfindData->EndOfFile),
 519                                          search_path,
 520                                          cifs_sb, xid))
 521                                 cFYI(1, ("Unrecognized sfu inode type"));
 522
 523                         cFYI(1, ("sfu mode 0%o", inode->i_mode));
 524                 } else {
 525                         inode->i_mode |= S_IFREG;
 526                         /* treat the dos attribute of read-only as read-only
 527                            mode e.g. 555 */
 528                         if (cifsInfo->cifsAttrs & ATTR_READONLY)
 529                                 inode->i_mode &= ~(S_IWUGO);
 530                         else if ((inode->i_mode & S_IWUGO) == 0)
 531                                 /* the ATTR_READONLY flag may have been */
 532                                 /* changed on server -- set any w bits  */
 533                                 /* allowed by mnt_file_mode             */
 534                                 inode->i_mode |= (S_IWUGO &
 535                                                   cifs_sb->mnt_file_mode);
 536                 /* BB add code here -
 537                    validate if device or weird share or device type? */
 538                 }
 539
 540                 spin_lock(&inode->i_lock);
 541                 if (is_size_safe_to_change(cifsInfo,
 542                                            le64_to_cpu(pfindData->EndOfFile))) {
 543                         /* can not safely shrink the file size here if the
 544                            client is writing to it due to potential races */
 545                         i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
 546
 547                         /* 512 bytes (2**9) is the fake blocksize that must be
 548                            used for this calculation */
 549                         inode->i_blocks = (512 - 1 + le64_to_cpu(
 550                                            pfindData->AllocationSize)) >> 9;
 551                 }
 552                 spin_unlock(&inode->i_lock);
 553
 554                 inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
 555
 556                 /* BB fill in uid and gid here? with help from winbind?
 557                    or retrieve from NTFS stream extended attribute */
 558 #ifdef CONFIG_CIFS_EXPERIMENTAL
 559                 /* fill in 0777 bits from ACL */
 560                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
 561                         cFYI(1, ("Getting mode bits from ACL"));
 562                         acl_to_uid_mode(inode, search_path);
 563                 }
 564 #endif
 565                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
 566                         /* fill in remaining high mode bits e.g. SUID, VTX */
 567                         get_sfu_mode(inode, search_path, cifs_sb, xid);
 568                 } else if (atomic_read(&cifsInfo->inUse) == 0) {
 569                         inode->i_uid = cifs_sb->mnt_uid;
 570                         inode->i_gid = cifs_sb->mnt_gid;
 571                         /* set so we do not keep refreshing these fields with
 572                            bad data after user has changed them in memory */
 573                         atomic_set(&cifsInfo->inUse, 1);
 574                 }
 575
 576                 cifs_set_ops(inode);
 577         }
 578         kfree(buf);
 579         return rc;
 580 }
 581
 582 static const struct inode_operations cifs_ipc_inode_ops = {
 583         .lookup = cifs_lookup,
 584 };
 585
 586 /* gets root inode */
 587 struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
 588 {
 589         int xid;
 590         struct cifs_sb_info *cifs_sb;
 591         struct inode *inode;
 592         long rc;
 593
 594         inode = iget_locked(sb, ino);
 595         if (!inode)
 596                 return ERR_PTR(-ENOMEM);
 597         if (!(inode->i_state & I_NEW))
 598                 return inode;
 599
 600         cifs_sb = CIFS_SB(inode->i_sb);
 601         xid = GetXid();
 602
 603         if (cifs_sb->tcon->unix_ext)
 604                 rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
 605         else
 606                 rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid);
 607         if (rc && cifs_sb->tcon->ipc) {
 608                 cFYI(1, ("ipc connection - fake read inode"));
 609                 inode->i_mode |= S_IFDIR;
 610                 inode->i_nlink = 2;
 611                 inode->i_op = &cifs_ipc_inode_ops;
 612                 inode->i_fop = &simple_dir_operations;
 613                 inode->i_uid = cifs_sb->mnt_uid;
 614                 inode->i_gid = cifs_sb->mnt_gid;
 615                 _FreeXid(xid);
 616                 iget_failed(inode);
 617                 return ERR_PTR(rc);
 618         }
 619
 620         unlock_new_inode(inode);
 621
 622         /* can not call macro FreeXid here since in a void func
 623          * TODO: This is no longer true
 624          */
 625         _FreeXid(xid);
 626         return inode;
 627 }
 628
 629 int cifs_unlink(struct inode *inode, struct dentry *direntry)
 630 {
 631         int rc = 0;
 632         int xid;
 633         struct cifs_sb_info *cifs_sb;
 634         struct cifsTconInfo *pTcon;
 635         char *full_path = NULL;
 636         struct cifsInodeInfo *cifsInode;
 637         FILE_BASIC_INFO *pinfo_buf;
 638
 639         cFYI(1, ("cifs_unlink, inode = 0x%p", inode));
 640
 641         xid = GetXid();
 642
 643         if (inode)
 644                 cifs_sb = CIFS_SB(inode->i_sb);
 645         else
 646                 cifs_sb = CIFS_SB(direntry->d_sb);
 647         pTcon = cifs_sb->tcon;
 648
 649         /* Unlink can be called from rename so we can not grab the sem here
 650            since we deadlock otherwise */
 651 /*      mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
 652         full_path = build_path_from_dentry(direntry);
 653 /*      mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
 654         if (full_path == NULL) {
 655                 FreeXid(xid);
 656                 return -ENOMEM;
 657         }
 658
 659         if ((pTcon->ses->capabilities & CAP_UNIX) &&
 660                 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 661                         le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
 662                 rc = CIFSPOSIXDelFile(xid, pTcon, full_path,
 663                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
 664                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 665                 cFYI(1, ("posix del rc %d", rc));
 666                 if ((rc == 0) || (rc == -ENOENT))
 667                         goto psx_del_no_retry;
 668         }
 669
 670         rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
 671                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 672 psx_del_no_retry:
 673         if (!rc) {
 674                 if (direntry->d_inode)
 675                         drop_nlink(direntry->d_inode);
 676         } else if (rc == -ENOENT) {
 677                 d_drop(direntry);
 678         } else if (rc == -ETXTBSY) {
 679                 int oplock = FALSE;
 680                 __u16 netfid;
 681
 682                 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
 683                                  CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
 684                                  &netfid, &oplock, NULL, cifs_sb->local_nls,
 685                                  cifs_sb->mnt_cifs_flags &
 686                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 687                 if (rc == 0) {
 688                         CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
 689                                               cifs_sb->local_nls,
 690                                               cifs_sb->mnt_cifs_flags &
 691                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 692                         CIFSSMBClose(xid, pTcon, netfid);
 693                         if (direntry->d_inode)
 694                                 drop_nlink(direntry->d_inode);
 695                 }
 696         } else if (rc == -EACCES) {
 697                 /* try only if r/o attribute set in local lookup data? */
 698                 pinfo_buf = kzalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
 699                 if (pinfo_buf) {
 700                         /* ATTRS set to normal clears r/o bit */
 701                         pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
 702                         if (!(pTcon->ses->flags & CIFS_SES_NT4))
 703                                 rc = CIFSSMBSetTimes(xid, pTcon, full_path,
 704                                                      pinfo_buf,
 705                                                      cifs_sb->local_nls,
 706                                                      cifs_sb->mnt_cifs_flags &
 707                                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 708                         else
 709                                 rc = -EOPNOTSUPP;
 710
 711                         if (rc == -EOPNOTSUPP) {
 712                                 int oplock = FALSE;
 713                                 __u16 netfid;
 714                         /*      rc = CIFSSMBSetAttrLegacy(xid, pTcon,
 715                                                           full_path,
 716                                                           (__u16)ATTR_NORMAL,
 717                                                           cifs_sb->local_nls);
 718                            For some strange reason it seems that NT4 eats the
 719                            old setattr call without actually setting the
 720                            attributes so on to the third attempted workaround
 721                            */
 722
 723                         /* BB could scan to see if we already have it open
 724                            and pass in pid of opener to function */
 725                                 rc = CIFSSMBOpen(xid, pTcon, full_path,
 726                                                  FILE_OPEN, SYNCHRONIZE |
 727                                                  FILE_WRITE_ATTRIBUTES, 0,
 728                                                  &netfid, &oplock, NULL,
 729                                                  cifs_sb->local_nls,
 730                                                  cifs_sb->mnt_cifs_flags &
 731                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 732                                 if (rc == 0) {
 733                                         rc = CIFSSMBSetFileTimes(xid, pTcon,
 734                                                                  pinfo_buf,
 735                                                                  netfid);
 736                                         CIFSSMBClose(xid, pTcon, netfid);
 737                                 }
 738                         }
 739                         kfree(pinfo_buf);
 740                 }
 741                 if (rc == 0) {
 742                         rc = CIFSSMBDelFile(xid, pTcon, full_path,
 743                                             cifs_sb->local_nls,
 744                                             cifs_sb->mnt_cifs_flags &
 745                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 746                         if (!rc) {
 747                                 if (direntry->d_inode)
 748                                         drop_nlink(direntry->d_inode);
 749                         } else if (rc == -ETXTBSY) {
 750                                 int oplock = FALSE;
 751                                 __u16 netfid;
 752
 753                                 rc = CIFSSMBOpen(xid, pTcon, full_path,
 754                                                  FILE_OPEN, DELETE,
 755                                                  CREATE_NOT_DIR |
 756                                                  CREATE_DELETE_ON_CLOSE,
 757                                                  &netfid, &oplock, NULL,
 758                                                  cifs_sb->local_nls,
 759                                                  cifs_sb->mnt_cifs_flags &
 760                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 761                                 if (rc == 0) {
 762                                         CIFSSMBRenameOpenFile(xid, pTcon,
 763                                                 netfid, NULL,
 764                                                 cifs_sb->local_nls,
 765                                                 cifs_sb->mnt_cifs_flags &
 766                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 767                                         CIFSSMBClose(xid, pTcon, netfid);
 768                                         if (direntry->d_inode)
 769                                                 drop_nlink(direntry->d_inode);
 770                                 }
 771                         /* BB if rc = -ETXTBUSY goto the rename logic BB */
 772                         }
 773                 }
 774         }
 775         if (direntry->d_inode) {
 776                 cifsInode = CIFS_I(direntry->d_inode);
 777                 cifsInode->time = 0;    /* will force revalidate to get info
 778                                            when needed */
 779                 direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
 780         }
 781         if (inode) {
 782                 inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
 783                 cifsInode = CIFS_I(inode);
 784                 cifsInode->time = 0;    /* force revalidate of dir as well */
 785         }
 786
 787         kfree(full_path);
 788         FreeXid(xid);
 789         return rc;
 790 }
 791
 792 static void posix_fill_in_inode(struct inode *tmp_inode,
 793         FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
 794 {
 795         struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
 796         loff_t local_size;
 797         struct timespec local_mtime;
 798
 799         cifsInfo->time = jiffies;
 800         atomic_inc(&cifsInfo->inUse);
 801
 802         /* save mtime and size */
 803         local_mtime = tmp_inode->i_mtime;
 804         local_size  = tmp_inode->i_size;
 805
 806         cifs_unix_info_to_inode(tmp_inode, pData, 1);
 807         cifs_set_ops(tmp_inode);
 808
 809         if (!S_ISREG(tmp_inode->i_mode))
 810                 return;
 811
 812         /*
 813          * No sense invalidating pages for new inode
 814          * since we we have not started caching
 815          * readahead file data yet.
 816          */
 817         if (isNewInode)
 818                 return;
 819
 820         if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
 821                 (local_size == tmp_inode->i_size)) {
 822                 cFYI(1, ("inode exists but unchanged"));
 823         } else {
 824                 /* file may have changed on server */
 825                 cFYI(1, ("invalidate inode, readdir detected change"));
 826                 invalidate_remote_inode(tmp_inode);
 827         }
 828 }
 829
 830 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
 831 {
 832         int rc = 0;
 833         int xid;
 834         struct cifs_sb_info *cifs_sb;
 835         struct cifsTconInfo *pTcon;
 836         char *full_path = NULL;
 837         struct inode *newinode = NULL;
 838
 839         cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
 840
 841         xid = GetXid();
 842
 843         cifs_sb = CIFS_SB(inode->i_sb);
 844         pTcon = cifs_sb->tcon;
 845
 846         full_path = build_path_from_dentry(direntry);
 847         if (full_path == NULL) {
 848                 FreeXid(xid);
 849                 return -ENOMEM;
 850         }
 851
 852         if ((pTcon->ses->capabilities & CAP_UNIX) &&
 853                 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 854                         le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
 855                 u32 oplock = 0;
 856                 FILE_UNIX_BASIC_INFO *pInfo =
 857                         kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 858                 if (pInfo == NULL) {
 859                         rc = -ENOMEM;
 860                         goto mkdir_out;
 861                 }
 862
 863                 mode &= ~current->fs->umask;
 864                 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
 865                                 mode, NULL /* netfid */, pInfo, &oplock,
 866                                 full_path, cifs_sb->local_nls,
 867                                 cifs_sb->mnt_cifs_flags &
 868                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 869                 if (rc == -EOPNOTSUPP) {
 870                         kfree(pInfo);
 871                         goto mkdir_retry_old;
 872                 } else if (rc) {
 873                         cFYI(1, ("posix mkdir returned 0x%x", rc));
 874                         d_drop(direntry);
 875                 } else {
 876                         int obj_type;
 877                         if (pInfo->Type == cpu_to_le32(-1)) {
 878                                 /* no return info, go query for it */
 879                                 kfree(pInfo);
 880                                 goto mkdir_get_info;
 881                         }
 882 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
 883         to set uid/gid */
 884                         inc_nlink(inode);
 885                         if (pTcon->nocase)
 886                                 direntry->d_op = &cifs_ci_dentry_ops;
 887                         else
 888                                 direntry->d_op = &cifs_dentry_ops;
 889
 890                         newinode = new_inode(inode->i_sb);
 891                         if (newinode == NULL) {
 892                                 kfree(pInfo);
 893                                 goto mkdir_get_info;
 894                         }
 895                         /* Is an i_ino of zero legal? */
 896                         /* Are there sanity checks we can use to ensure that
 897                            the server is really filling in that field? */
 898                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 899                                 newinode->i_ino =
 900                                         (unsigned long)pInfo->UniqueId;
 901                         } /* note ino incremented to unique num in new_inode */
 902                         if (inode->i_sb->s_flags & MS_NOATIME)
 903                                 newinode->i_flags |= S_NOATIME | S_NOCMTIME;
 904                         newinode->i_nlink = 2;
 905
 906                         insert_inode_hash(newinode);
 907                         d_instantiate(direntry, newinode);
 908
 909                         /* we already checked in POSIXCreate whether
 910                            frame was long enough */
 911                         posix_fill_in_inode(direntry->d_inode,
 912                                         pInfo, &obj_type, 1 /* NewInode */);
 913 #ifdef CONFIG_CIFS_DEBUG2
 914                         cFYI(1, ("instantiated dentry %p %s to inode %p",
 915                                 direntry, direntry->d_name.name, newinode));
 916
 917                         if (newinode->i_nlink != 2)
 918                                 cFYI(1, ("unexpected number of links %d",
 919                                         newinode->i_nlink));
 920 #endif
 921                 }
 922                 kfree(pInfo);
 923                 goto mkdir_out;
 924         }
 925 mkdir_retry_old:
 926         /* BB add setting the equivalent of mode via CreateX w/ACLs */
 927         rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
 928                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 929         if (rc) {
 930                 cFYI(1, ("cifs_mkdir returned 0x%x", rc));
 931                 d_drop(direntry);
 932         } else {
 933 mkdir_get_info:
 934                 inc_nlink(inode);
 935                 if (pTcon->unix_ext)
 936                         rc = cifs_get_inode_info_unix(&newinode, full_path,
 937                                                       inode->i_sb, xid);
 938                 else
 939                         rc = cifs_get_inode_info(&newinode, full_path, NULL,
 940                                                  inode->i_sb, xid);
 941
 942                 if (pTcon->nocase)
 943                         direntry->d_op = &cifs_ci_dentry_ops;
 944                 else
 945                         direntry->d_op = &cifs_dentry_ops;
 946                 d_instantiate(direntry, newinode);
 947                  /* setting nlink not necessary except in cases where we
 948                   * failed to get it from the server or was set bogus */
 949                 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
 950                                 direntry->d_inode->i_nlink = 2;
 951                 if (pTcon->unix_ext) {
 952                         mode &= ~current->fs->umask;
 953                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
 954                                 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
 955                                                     mode,
 956                                                     (__u64)current->fsuid,
 957                                                     (__u64)current->fsgid,
 958                                                     0 /* dev_t */,
 959                                                     cifs_sb->local_nls,
 960                                                     cifs_sb->mnt_cifs_flags &
 961                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 962                         } else {
 963                                 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
 964                                                     mode, (__u64)-1,
 965                                                     (__u64)-1, 0 /* dev_t */,
 966                                                     cifs_sb->local_nls,
 967                                                     cifs_sb->mnt_cifs_flags &
 968                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 969                         }
 970                 } else {
 971                         /* BB to be implemented via Windows secrty descriptors
 972                            eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
 973                                                  -1, -1, local_nls); */
 974                         if (direntry->d_inode) {
 975                                 direntry->d_inode->i_mode = mode;
 976                                 direntry->d_inode->i_mode |= S_IFDIR;
 977                                 if (cifs_sb->mnt_cifs_flags &
 978                                      CIFS_MOUNT_SET_UID) {
 979                                         direntry->d_inode->i_uid =
 980                                                 current->fsuid;
 981                                         direntry->d_inode->i_gid =
 982                                                 current->fsgid;
 983                                 }
 984                         }
 985                 }
 986         }
 987 mkdir_out:
 988         kfree(full_path);
 989         FreeXid(xid);
 990         return rc;
 991 }
 992
 993 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
 994 {
 995         int rc = 0;
 996         int xid;
 997         struct cifs_sb_info *cifs_sb;
 998         struct cifsTconInfo *pTcon;
 999         char *full_path = NULL;
1000         struct cifsInodeInfo *cifsInode;
1001
1002         cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
1003
1004         xid = GetXid();
1005
1006         cifs_sb = CIFS_SB(inode->i_sb);
1007         pTcon = cifs_sb->tcon;
1008
1009         full_path = build_path_from_dentry(direntry);
1010         if (full_path == NULL) {
1011                 FreeXid(xid);
1012                 return -ENOMEM;
1013         }
1014
1015         rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1016                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1017
1018         if (!rc) {
1019                 drop_nlink(inode);
1020                 spin_lock(&direntry->d_inode->i_lock);
1021                 i_size_write(direntry->d_inode, 0);
1022                 clear_nlink(direntry->d_inode);
1023                 spin_unlock(&direntry->d_inode->i_lock);
1024         }
1025
1026         cifsInode = CIFS_I(direntry->d_inode);
1027         cifsInode->time = 0;    /* force revalidate to go get info when
1028                                    needed */
1029         direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1030                 current_fs_time(inode->i_sb);
1031
1032         kfree(full_path);
1033         FreeXid(xid);
1034         return rc;
1035 }
1036
1037 int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
1038         struct inode *target_inode, struct dentry *target_direntry)
1039 {
1040         char *fromName;
1041         char *toName;
1042         struct cifs_sb_info *cifs_sb_source;
1043         struct cifs_sb_info *cifs_sb_target;
1044         struct cifsTconInfo *pTcon;
1045         int xid;
1046         int rc = 0;
1047
1048         xid = GetXid();
1049
1050         cifs_sb_target = CIFS_SB(target_inode->i_sb);
1051         cifs_sb_source = CIFS_SB(source_inode->i_sb);
1052         pTcon = cifs_sb_source->tcon;
1053
1054         if (pTcon != cifs_sb_target->tcon) {
1055                 FreeXid(xid);
1056                 return -EXDEV;  /* BB actually could be allowed if same server,
1057                                    but different share.
1058                                    Might eventually add support for this */
1059         }
1060
1061         /* we already  have the rename sem so we do not need to grab it again
1062            here to protect the path integrity */
1063         fromName = build_path_from_dentry(source_direntry);
1064         toName = build_path_from_dentry(target_direntry);
1065         if ((fromName == NULL) || (toName == NULL)) {
1066                 rc = -ENOMEM;
1067                 goto cifs_rename_exit;
1068         }
1069
1070         rc = CIFSSMBRename(xid, pTcon, fromName, toName,
1071                            cifs_sb_source->local_nls,
1072                            cifs_sb_source->mnt_cifs_flags &
1073                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1074         if (rc == -EEXIST) {
1075                 /* check if they are the same file because rename of hardlinked
1076                    files is a noop */
1077                 FILE_UNIX_BASIC_INFO *info_buf_source;
1078                 FILE_UNIX_BASIC_INFO *info_buf_target;
1079
1080                 info_buf_source =
1081                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1082                 if (info_buf_source != NULL) {
1083                         info_buf_target = info_buf_source + 1;
1084                         if (pTcon->unix_ext)
1085                                 rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
1086                                         info_buf_source,
1087                                         cifs_sb_source->local_nls,
1088                                         cifs_sb_source->mnt_cifs_flags &
1089                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1090                         /* else rc is still EEXIST so will fall through to
1091                            unlink the target and retry rename */
1092                         if (rc == 0) {
1093                                 rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
1094                                                 info_buf_target,
1095                                                 cifs_sb_target->local_nls,
1096                                                 /* remap based on source sb */
1097                                                 cifs_sb_source->mnt_cifs_flags &
1098                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
1099                         }
1100                         if ((rc == 0) &&
1101                             (info_buf_source->UniqueId ==
1102                              info_buf_target->UniqueId)) {
1103                         /* do not rename since the files are hardlinked which
1104                            is a noop */
1105                         } else {
1106                         /* we either can not tell the files are hardlinked
1107                            (as with Windows servers) or files are not
1108                            hardlinked so delete the target manually before
1109                            renaming to follow POSIX rather than Windows
1110                            semantics */
1111                                 cifs_unlink(target_inode, target_direntry);
1112                                 rc = CIFSSMBRename(xid, pTcon, fromName,
1113                                                    toName,
1114                                                    cifs_sb_source->local_nls,
1115                                                    cifs_sb_source->mnt_cifs_flags
1116                                                    & CIFS_MOUNT_MAP_SPECIAL_CHR);
1117                         }
1118                         kfree(info_buf_source);
1119                 } /* if we can not get memory just leave rc as EEXIST */
1120         }
1121
1122         if (rc)
1123                 cFYI(1, ("rename rc %d", rc));
1124
1125         if ((rc == -EIO) || (rc == -EEXIST)) {
1126                 int oplock = FALSE;
1127                 __u16 netfid;
1128
1129                 /* BB FIXME Is Generic Read correct for rename? */
1130                 /* if renaming directory - we should not say CREATE_NOT_DIR,
1131                    need to test renaming open directory, also GENERIC_READ
1132                    might not right be right access to request */
1133                 rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
1134                                  CREATE_NOT_DIR, &netfid, &oplock, NULL,
1135                                  cifs_sb_source->local_nls,
1136                                  cifs_sb_source->mnt_cifs_flags &
1137                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
1138                 if (rc == 0) {
1139                         rc = CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
1140                                               cifs_sb_source->local_nls,
1141                                               cifs_sb_source->mnt_cifs_flags &
1142                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1143                         CIFSSMBClose(xid, pTcon, netfid);
1144                 }
1145         }
1146
1147 cifs_rename_exit:
1148         kfree(fromName);
1149         kfree(toName);
1150         FreeXid(xid);
1151         return rc;
1152 }
1153
1154 int cifs_revalidate(struct dentry *direntry)
1155 {
1156         int xid;
1157         int rc = 0, wbrc = 0;
1158         char *full_path;
1159         struct cifs_sb_info *cifs_sb;
1160         struct cifsInodeInfo *cifsInode;
1161         loff_t local_size;
1162         struct timespec local_mtime;
1163         int invalidate_inode = FALSE;
1164
1165         if (direntry->d_inode == NULL)
1166                 return -ENOENT;
1167
1168         cifsInode = CIFS_I(direntry->d_inode);
1169
1170         if (cifsInode == NULL)
1171                 return -ENOENT;
1172
1173         /* no sense revalidating inode info on file that no one can write */
1174         if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
1175                 return rc;
1176
1177         xid = GetXid();
1178
1179         cifs_sb = CIFS_SB(direntry->d_sb);
1180
1181         /* can not safely grab the rename sem here if rename calls revalidate
1182            since that would deadlock */
1183         full_path = build_path_from_dentry(direntry);
1184         if (full_path == NULL) {
1185                 FreeXid(xid);
1186                 return -ENOMEM;
1187         }
1188         cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1189                  "jiffies %ld", full_path, direntry->d_inode,
1190                  direntry->d_inode->i_count.counter, direntry,
1191                  direntry->d_time, jiffies));
1192
1193         if (cifsInode->time == 0) {
1194                 /* was set to zero previously to force revalidate */
1195         } else if (time_before(jiffies, cifsInode->time + HZ) &&
1196                    lookupCacheEnabled) {
1197                 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
1198                     (direntry->d_inode->i_nlink == 1)) {
1199                         kfree(full_path);
1200                         FreeXid(xid);
1201                         return rc;
1202                 } else {
1203                         cFYI(1, ("Have to revalidate file due to hardlinks"));
1204                 }
1205         }
1206
1207         /* save mtime and size */
1208         local_mtime = direntry->d_inode->i_mtime;
1209         local_size = direntry->d_inode->i_size;
1210
1211         if (cifs_sb->tcon->unix_ext) {
1212                 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
1213                                               direntry->d_sb, xid);
1214                 if (rc) {
1215                         cFYI(1, ("error on getting revalidate info %d", rc));
1216 /*                      if (rc != -ENOENT)
1217                                 rc = 0; */      /* BB should we cache info on
1218                                                    certain errors? */
1219                 }
1220         } else {
1221                 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
1222                                          direntry->d_sb, xid);
1223                 if (rc) {
1224                         cFYI(1, ("error on getting revalidate info %d", rc));
1225 /*                      if (rc != -ENOENT)
1226                                 rc = 0; */      /* BB should we cache info on
1227                                                    certain errors? */
1228                 }
1229         }
1230         /* should we remap certain errors, access denied?, to zero */
1231
1232         /* if not oplocked, we invalidate inode pages if mtime or file size
1233            had changed on server */
1234
1235         if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
1236             (local_size == direntry->d_inode->i_size)) {
1237                 cFYI(1, ("cifs_revalidate - inode unchanged"));
1238         } else {
1239                 /* file may have changed on server */
1240                 if (cifsInode->clientCanCacheRead) {
1241                         /* no need to invalidate inode pages since we were the
1242                            only ones who could have modified the file and the
1243                            server copy is staler than ours */
1244                 } else {
1245                         invalidate_inode = TRUE;
1246                 }
1247         }
1248
1249         /* can not grab this sem since kernel filesys locking documentation
1250            indicates i_mutex may be taken by the kernel on lookup and rename
1251            which could deadlock if we grab the i_mutex here as well */
1252 /*      mutex_lock(&direntry->d_inode->i_mutex);*/
1253         /* need to write out dirty pages here  */
1254         if (direntry->d_inode->i_mapping) {
1255                 /* do we need to lock inode until after invalidate completes
1256                    below? */
1257                 wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
1258                 if (wbrc)
1259                         CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1260         }
1261         if (invalidate_inode) {
1262         /* shrink_dcache not necessary now that cifs dentry ops
1263         are exported for negative dentries */
1264 /*              if (S_ISDIR(direntry->d_inode->i_mode))
1265                         shrink_dcache_parent(direntry); */
1266                 if (S_ISREG(direntry->d_inode->i_mode)) {
1267                         if (direntry->d_inode->i_mapping)
1268                                 wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
1269                                 if (wbrc)
1270                                         CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1271                         /* may eventually have to do this for open files too */
1272                         if (list_empty(&(cifsInode->openFileList))) {
1273                                 /* changed on server - flush read ahead pages */
1274                                 cFYI(1, ("Invalidating read ahead data on "
1275                                          "closed file"));
1276                                 invalidate_remote_inode(direntry->d_inode);
1277                         }
1278                 }
1279         }
1280 /*      mutex_unlock(&direntry->d_inode->i_mutex); */
1281
1282         kfree(full_path);
1283         FreeXid(xid);
1284         return rc;
1285 }
1286
1287 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1288         struct kstat *stat)
1289 {
1290         int err = cifs_revalidate(dentry);
1291         if (!err) {
1292                 generic_fillattr(dentry->d_inode, stat);
1293                 stat->blksize = CIFS_MAX_MSGSIZE;
1294         }
1295         return err;
1296 }
1297
1298 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1299 {
1300         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1301         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1302         struct page *page;
1303         int rc = 0;
1304
1305         page = grab_cache_page(mapping, index);
1306         if (!page)
1307                 return -ENOMEM;
1308
1309         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1310         unlock_page(page);
1311         page_cache_release(page);
1312         return rc;
1313 }
1314
1315 static int cifs_vmtruncate(struct inode *inode, loff_t offset)
1316 {
1317         struct address_space *mapping = inode->i_mapping;
1318         unsigned long limit;
1319
1320         spin_lock(&inode->i_lock);
1321         if (inode->i_size < offset)
1322                 goto do_expand;
1323         /*
1324          * truncation of in-use swapfiles is disallowed - it would cause
1325          * subsequent swapout to scribble on the now-freed blocks.
1326          */
1327         if (IS_SWAPFILE(inode)) {
1328                 spin_unlock(&inode->i_lock);
1329                 goto out_busy;
1330         }
1331         i_size_write(inode, offset);
1332         spin_unlock(&inode->i_lock);
1333         /*
1334          * unmap_mapping_range is called twice, first simply for efficiency
1335          * so that truncate_inode_pages does fewer single-page unmaps. However
1336          * after this first call, and before truncate_inode_pages finishes,
1337          * it is possible for private pages to be COWed, which remain after
1338          * truncate_inode_pages finishes, hence the second unmap_mapping_range
1339          * call must be made for correctness.
1340          */
1341         unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1342         truncate_inode_pages(mapping, offset);
1343         unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1344         goto out_truncate;
1345
1346 do_expand:
1347         limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1348         if (limit != RLIM_INFINITY && offset > limit) {
1349                 spin_unlock(&inode->i_lock);
1350                 goto out_sig;
1351         }
1352         if (offset > inode->i_sb->s_maxbytes) {
1353                 spin_unlock(&inode->i_lock);
1354                 goto out_big;
1355         }
1356         i_size_write(inode, offset);
1357         spin_unlock(&inode->i_lock);
1358 out_truncate:
1359         if (inode->i_op && inode->i_op->truncate)
1360                 inode->i_op->truncate(inode);
1361         return 0;
1362 out_sig:
1363         send_sig(SIGXFSZ, current, 0);
1364 out_big:
1365         return -EFBIG;
1366 out_busy:
1367         return -ETXTBSY;
1368 }
1369
1370 int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1371 {
1372         int xid;
1373         struct cifs_sb_info *cifs_sb;
1374         struct cifsTconInfo *pTcon;
1375         char *full_path = NULL;
1376         int rc = -EACCES;
1377         struct cifsFileInfo *open_file = NULL;
1378         FILE_BASIC_INFO time_buf;
1379         int set_time = FALSE;
1380         int set_dosattr = FALSE;
1381         __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
1382         __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
1383         __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
1384         struct cifsInodeInfo *cifsInode;
1385
1386         xid = GetXid();
1387
1388         cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
1389                  direntry->d_name.name, attrs->ia_valid));
1390
1391         cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
1392         pTcon = cifs_sb->tcon;
1393
1394         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1395                 /* check if we have permission to change attrs */
1396                 rc = inode_change_ok(direntry->d_inode, attrs);
1397                 if (rc < 0) {
1398                         FreeXid(xid);
1399                         return rc;
1400                 } else
1401                         rc = 0;
1402         }
1403
1404         full_path = build_path_from_dentry(direntry);
1405         if (full_path == NULL) {
1406                 FreeXid(xid);
1407                 return -ENOMEM;
1408         }
1409         cifsInode = CIFS_I(direntry->d_inode);
1410
1411         /* BB check if we need to refresh inode from server now ? BB */
1412
1413         if (attrs->ia_valid & ATTR_SIZE) {
1414                 /*
1415                    Flush data before changing file size on server. If the
1416                    flush returns error, store it to report later and continue.
1417                    BB: This should be smarter. Why bother flushing pages that
1418                    will be truncated anyway? Also, should we error out here if
1419                    the flush returns error?
1420                  */
1421                 rc = filemap_write_and_wait(direntry->d_inode->i_mapping);
1422                 if (rc != 0) {
1423                         CIFS_I(direntry->d_inode)->write_behind_rc = rc;
1424                         rc = 0;
1425                 }
1426
1427                 /* To avoid spurious oplock breaks from server, in the case of
1428                    inodes that we already have open, avoid doing path based
1429                    setting of file size if we can do it by handle.
1430                    This keeps our caching token (oplock) and avoids timeouts
1431                    when the local oplock break takes longer to flush
1432                    writebehind data than the SMB timeout for the SetPathInfo
1433                    request would allow */
1434
1435                 open_file = find_writable_file(cifsInode);
1436                 if (open_file) {
1437                         __u16 nfid = open_file->netfid;
1438                         __u32 npid = open_file->pid;
1439                         rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
1440                                                 nfid, npid, FALSE);
1441                         atomic_dec(&open_file->wrtPending);
1442                         cFYI(1, ("SetFSize for attrs rc = %d", rc));
1443                         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1444                                 unsigned int bytes_written;
1445                                 rc = CIFSSMBWrite(xid, pTcon,
1446                                                   nfid, 0, attrs->ia_size,
1447                                                   &bytes_written, NULL, NULL,
1448                                                   1 /* 45 seconds */);
1449                                 cFYI(1, ("Wrt seteof rc %d", rc));
1450                         }
1451                 } else
1452                         rc = -EINVAL;
1453
1454                 if (rc != 0) {
1455                         /* Set file size by pathname rather than by handle
1456                            either because no valid, writeable file handle for
1457                            it was found or because there was an error setting
1458                            it by handle */
1459                         rc = CIFSSMBSetEOF(xid, pTcon, full_path,
1460                                            attrs->ia_size, FALSE,
1461                                            cifs_sb->local_nls,
1462                                            cifs_sb->mnt_cifs_flags &
1463                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1464                         cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1465                         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1466                                 __u16 netfid;
1467                                 int oplock = FALSE;
1468
1469                                 rc = SMBLegacyOpen(xid, pTcon, full_path,
1470                                         FILE_OPEN,
1471                                         SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1472                                         CREATE_NOT_DIR, &netfid, &oplock,
1473                                         NULL, cifs_sb->local_nls,
1474                                         cifs_sb->mnt_cifs_flags &
1475                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1476                                 if (rc == 0) {
1477                                         unsigned int bytes_written;
1478                                         rc = CIFSSMBWrite(xid, pTcon,
1479                                                         netfid, 0,
1480                                                         attrs->ia_size,
1481                                                         &bytes_written, NULL,
1482                                                         NULL, 1 /* 45 sec */);
1483                                         cFYI(1, ("wrt seteof rc %d", rc));
1484                                         CIFSSMBClose(xid, pTcon, netfid);
1485                                 }
1486
1487                         }
1488                 }
1489
1490                 /* Server is ok setting allocation size implicitly - no need
1491                    to call:
1492                 CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE,
1493                          cifs_sb->local_nls);
1494                    */
1495
1496                 if (rc == 0) {
1497                         rc = cifs_vmtruncate(direntry->d_inode, attrs->ia_size);
1498                         cifs_truncate_page(direntry->d_inode->i_mapping,
1499                                            direntry->d_inode->i_size);
1500                 } else
1501                         goto cifs_setattr_exit;
1502         }
1503         if (attrs->ia_valid & ATTR_UID) {
1504                 cFYI(1, ("UID changed to %d", attrs->ia_uid));
1505                 uid = attrs->ia_uid;
1506         }
1507         if (attrs->ia_valid & ATTR_GID) {
1508                 cFYI(1, ("GID changed to %d", attrs->ia_gid));
1509                 gid = attrs->ia_gid;
1510         }
1511
1512         time_buf.Attributes = 0;
1513
1514         /* skip mode change if it's just for clearing setuid/setgid */
1515         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1516                 attrs->ia_valid &= ~ATTR_MODE;
1517
1518         if (attrs->ia_valid & ATTR_MODE) {
1519                 cFYI(1, ("Mode changed to 0x%x", attrs->ia_mode));
1520                 mode = attrs->ia_mode;
1521         }
1522
1523         if ((pTcon->unix_ext)
1524             && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
1525                 rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
1526                                          0 /* dev_t */, cifs_sb->local_nls,
1527                                          cifs_sb->mnt_cifs_flags &
1528                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1529         else if (attrs->ia_valid & ATTR_MODE) {
1530                 rc = 0;
1531 #ifdef CONFIG_CIFS_EXPERIMENTAL
1532                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1533                         rc = mode_to_acl(direntry->d_inode, full_path, mode);
1534                 else if ((mode & S_IWUGO) == 0) {
1535 #else
1536                 if ((mode & S_IWUGO) == 0) {
1537 #endif
1538                         /* not writeable */
1539                         if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1540                                 set_dosattr = TRUE;
1541                                 time_buf.Attributes =
1542                                         cpu_to_le32(cifsInode->cifsAttrs |
1543                                                     ATTR_READONLY);
1544                         }
1545                 } else if (cifsInode->cifsAttrs & ATTR_READONLY) {
1546                         /* If file is readonly on server, we would
1547                         not be able to write to it - so if any write
1548                         bit is enabled for user or group or other we
1549                         need to at least try to remove r/o dos attr */
1550                         set_dosattr = TRUE;
1551                         time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
1552                                             (~ATTR_READONLY));
1553                         /* Windows ignores set to zero */
1554                         if (time_buf.Attributes == 0)
1555                                 time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
1556                 }
1557 #ifdef CONFIG_CIFS_EXPERIMENTAL
1558                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1559                         mode_to_acl(direntry->d_inode, full_path, mode);
1560 #endif
1561         }
1562
1563         if (attrs->ia_valid & ATTR_ATIME) {
1564                 set_time = TRUE;
1565                 time_buf.LastAccessTime =
1566                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1567         } else
1568                 time_buf.LastAccessTime = 0;
1569
1570         if (attrs->ia_valid & ATTR_MTIME) {
1571                 set_time = TRUE;
1572                 time_buf.LastWriteTime =
1573                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1574         } else
1575                 time_buf.LastWriteTime = 0;
1576         /* Do not set ctime explicitly unless other time
1577            stamps are changed explicitly (i.e. by utime()
1578            since we would then have a mix of client and
1579            server times */
1580
1581         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1582                 set_time = TRUE;
1583                 /* Although Samba throws this field away
1584                 it may be useful to Windows - but we do
1585                 not want to set ctime unless some other
1586                 timestamp is changing */
1587                 cFYI(1, ("CIFS - CTIME changed"));
1588                 time_buf.ChangeTime =
1589                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1590         } else
1591                 time_buf.ChangeTime = 0;
1592
1593         if (set_time || set_dosattr) {
1594                 time_buf.CreationTime = 0;      /* do not change */
1595                 /* In the future we should experiment - try setting timestamps
1596                    via Handle (SetFileInfo) instead of by path */
1597                 if (!(pTcon->ses->flags & CIFS_SES_NT4))
1598                         rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
1599                                              cifs_sb->local_nls,
1600                                              cifs_sb->mnt_cifs_flags &
1601                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1602                 else
1603                         rc = -EOPNOTSUPP;
1604
1605                 if (rc == -EOPNOTSUPP) {
1606                         int oplock = FALSE;
1607                         __u16 netfid;
1608
1609                         cFYI(1, ("calling SetFileInfo since SetPathInfo for "
1610                                  "times not supported by this server"));
1611                         /* BB we could scan to see if we already have it open
1612                            and pass in pid of opener to function */
1613                         rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1614                                          SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1615                                          CREATE_NOT_DIR, &netfid, &oplock,
1616                                          NULL, cifs_sb->local_nls,
1617                                          cifs_sb->mnt_cifs_flags &
1618                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1619                         if (rc == 0) {
1620                                 rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
1621                                                          netfid);
1622                                 CIFSSMBClose(xid, pTcon, netfid);
1623                         } else {
1624                         /* BB For even older servers we could convert time_buf
1625                            into old DOS style which uses two second
1626                            granularity */
1627
1628                         /* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
1629                                         &time_buf, cifs_sb->local_nls); */
1630                         }
1631                 }
1632                 /* Even if error on time set, no sense failing the call if
1633                 the server would set the time to a reasonable value anyway,
1634                 and this check ensures that we are not being called from
1635                 sys_utimes in which case we ought to fail the call back to
1636                 the user when the server rejects the call */
1637                 if ((rc) && (attrs->ia_valid &
1638                          (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
1639                         rc = 0;
1640         }
1641
1642         /* do not need local check to inode_check_ok since the server does
1643            that */
1644         if (!rc)
1645                 rc = inode_setattr(direntry->d_inode, attrs);
1646 cifs_setattr_exit:
1647         kfree(full_path);
1648         FreeXid(xid);
1649         return rc;
1650 }
1651
1652 #if 0
1653 void cifs_delete_inode(struct inode *inode)
1654 {
1655         cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
1656         /* may have to add back in if and when safe distributed caching of
1657            directories added e.g. via FindNotify */
1658 }
1659 #endif