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