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