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 struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
 570 {
 571         int xid;
 572         struct cifs_sb_info *cifs_sb;
 573         struct inode *inode;
 574         long rc;
 575
 576         inode = iget_locked(sb, ino);
 577         if (!inode)
 578                 return ERR_PTR(-ENOMEM);
 579         if (!(inode->i_state & I_NEW))
 580                 return inode;
 581
 582         cifs_sb = CIFS_SB(inode->i_sb);
 583         xid = GetXid();
 584
 585         if (cifs_sb->tcon->unix_ext)
 586                 rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
 587         else
 588                 rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid);
 589         if (rc && cifs_sb->tcon->ipc) {
 590                 cFYI(1, ("ipc connection - fake read inode"));
 591                 inode->i_mode |= S_IFDIR;
 592                 inode->i_nlink = 2;
 593                 inode->i_op = &cifs_ipc_inode_ops;
 594                 inode->i_fop = &simple_dir_operations;
 595                 inode->i_uid = cifs_sb->mnt_uid;
 596                 inode->i_gid = cifs_sb->mnt_gid;
 597                 _FreeXid(xid);
 598                 iget_failed(inode);
 599                 return ERR_PTR(rc);
 600         }
 601
 602         unlock_new_inode(inode);
 603
 604         /* can not call macro FreeXid here since in a void func
 605          * TODO: This is no longer true
 606          */
 607         _FreeXid(xid);
 608         return inode;
 609 }
 610
 611 int cifs_unlink(struct inode *inode, struct dentry *direntry)
 612 {
 613         int rc = 0;
 614         int xid;
 615         struct cifs_sb_info *cifs_sb;
 616         struct cifsTconInfo *pTcon;
 617         char *full_path = NULL;
 618         struct cifsInodeInfo *cifsInode;
 619         FILE_BASIC_INFO *pinfo_buf;
 620
 621         cFYI(1, ("cifs_unlink, inode = 0x%p", inode));
 622
 623         xid = GetXid();
 624
 625         if (inode)
 626                 cifs_sb = CIFS_SB(inode->i_sb);
 627         else
 628                 cifs_sb = CIFS_SB(direntry->d_sb);
 629         pTcon = cifs_sb->tcon;
 630
 631         /* Unlink can be called from rename so we can not grab the sem here
 632            since we deadlock otherwise */
 633 /*      mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
 634         full_path = build_path_from_dentry(direntry);
 635 /*      mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
 636         if (full_path == NULL) {
 637                 FreeXid(xid);
 638                 return -ENOMEM;
 639         }
 640
 641         if ((pTcon->ses->capabilities & CAP_UNIX) &&
 642                 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 643                         le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
 644                 rc = CIFSPOSIXDelFile(xid, pTcon, full_path,
 645                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
 646                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 647                 cFYI(1, ("posix del rc %d", rc));
 648                 if ((rc == 0) || (rc == -ENOENT))
 649                         goto psx_del_no_retry;
 650         }
 651
 652         rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
 653                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
 654 psx_del_no_retry:
 655         if (!rc) {
 656                 if (direntry->d_inode)
 657                         drop_nlink(direntry->d_inode);
 658         } else if (rc == -ENOENT) {
 659                 d_drop(direntry);
 660         } else if (rc == -ETXTBSY) {
 661                 int oplock = FALSE;
 662                 __u16 netfid;
 663
 664                 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
 665                                  CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
 666                                  &netfid, &oplock, NULL, cifs_sb->local_nls,
 667                                  cifs_sb->mnt_cifs_flags &
 668                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 669                 if (rc == 0) {
 670                         CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
 671                                               cifs_sb->local_nls,
 672                                               cifs_sb->mnt_cifs_flags &
 673                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 674                         CIFSSMBClose(xid, pTcon, netfid);
 675                         if (direntry->d_inode)
 676                                 drop_nlink(direntry->d_inode);
 677                 }
 678         } else if (rc == -EACCES) {
 679                 /* try only if r/o attribute set in local lookup data? */
 680                 pinfo_buf = kzalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
 681                 if (pinfo_buf) {
 682                         /* ATTRS set to normal clears r/o bit */
 683                         pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
 684                         if (!(pTcon->ses->flags & CIFS_SES_NT4))
 685                                 rc = CIFSSMBSetTimes(xid, pTcon, full_path,
 686                                                      pinfo_buf,
 687                                                      cifs_sb->local_nls,
 688                                                      cifs_sb->mnt_cifs_flags &
 689                                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 690                         else
 691                                 rc = -EOPNOTSUPP;
 692
 693                         if (rc == -EOPNOTSUPP) {
 694                                 int oplock = FALSE;
 695                                 __u16 netfid;
 696                         /*      rc = CIFSSMBSetAttrLegacy(xid, pTcon,
 697                                                           full_path,
 698                                                           (__u16)ATTR_NORMAL,
 699                                                           cifs_sb->local_nls);
 700                            For some strange reason it seems that NT4 eats the
 701                            old setattr call without actually setting the
 702                            attributes so on to the third attempted workaround
 703                            */
 704
 705                         /* BB could scan to see if we already have it open
 706                            and pass in pid of opener to function */
 707                                 rc = CIFSSMBOpen(xid, pTcon, full_path,
 708                                                  FILE_OPEN, SYNCHRONIZE |
 709                                                  FILE_WRITE_ATTRIBUTES, 0,
 710                                                  &netfid, &oplock, NULL,
 711                                                  cifs_sb->local_nls,
 712                                                  cifs_sb->mnt_cifs_flags &
 713                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 714                                 if (rc == 0) {
 715                                         rc = CIFSSMBSetFileTimes(xid, pTcon,
 716                                                                  pinfo_buf,
 717                                                                  netfid);
 718                                         CIFSSMBClose(xid, pTcon, netfid);
 719                                 }
 720                         }
 721                         kfree(pinfo_buf);
 722                 }
 723                 if (rc == 0) {
 724                         rc = CIFSSMBDelFile(xid, pTcon, full_path,
 725                                             cifs_sb->local_nls,
 726                                             cifs_sb->mnt_cifs_flags &
 727                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 728                         if (!rc) {
 729                                 if (direntry->d_inode)
 730                                         drop_nlink(direntry->d_inode);
 731                         } else if (rc == -ETXTBSY) {
 732                                 int oplock = FALSE;
 733                                 __u16 netfid;
 734
 735                                 rc = CIFSSMBOpen(xid, pTcon, full_path,
 736                                                  FILE_OPEN, DELETE,
 737                                                  CREATE_NOT_DIR |
 738                                                  CREATE_DELETE_ON_CLOSE,
 739                                                  &netfid, &oplock, NULL,
 740                                                  cifs_sb->local_nls,
 741                                                  cifs_sb->mnt_cifs_flags &
 742                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 743                                 if (rc == 0) {
 744                                         CIFSSMBRenameOpenFile(xid, pTcon,
 745                                                 netfid, NULL,
 746                                                 cifs_sb->local_nls,
 747                                                 cifs_sb->mnt_cifs_flags &
 748                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
 749                                         CIFSSMBClose(xid, pTcon, netfid);
 750                                         if (direntry->d_inode)
 751                                                 drop_nlink(direntry->d_inode);
 752                                 }
 753                         /* BB if rc = -ETXTBUSY goto the rename logic BB */
 754                         }
 755                 }
 756         }
 757         if (direntry->d_inode) {
 758                 cifsInode = CIFS_I(direntry->d_inode);
 759                 cifsInode->time = 0;    /* will force revalidate to get info
 760                                            when needed */
 761                 direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
 762         }
 763         if (inode) {
 764                 inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
 765                 cifsInode = CIFS_I(inode);
 766                 cifsInode->time = 0;    /* force revalidate of dir as well */
 767         }
 768
 769         kfree(full_path);
 770         FreeXid(xid);
 771         return rc;
 772 }
 773
 774 static void posix_fill_in_inode(struct inode *tmp_inode,
 775         FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
 776 {
 777         loff_t local_size;
 778         struct timespec local_mtime;
 779
 780         struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
 781         struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
 782
 783         __u32 type = le32_to_cpu(pData->Type);
 784         __u64 num_of_bytes = le64_to_cpu(pData->NumOfBytes);
 785         __u64 end_of_file = le64_to_cpu(pData->EndOfFile);
 786         cifsInfo->time = jiffies;
 787         atomic_inc(&cifsInfo->inUse);
 788
 789         /* save mtime and size */
 790         local_mtime = tmp_inode->i_mtime;
 791         local_size  = tmp_inode->i_size;
 792
 793         tmp_inode->i_atime =
 794             cifs_NTtimeToUnix(le64_to_cpu(pData->LastAccessTime));
 795         tmp_inode->i_mtime =
 796             cifs_NTtimeToUnix(le64_to_cpu(pData->LastModificationTime));
 797         tmp_inode->i_ctime =
 798             cifs_NTtimeToUnix(le64_to_cpu(pData->LastStatusChange));
 799
 800         tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
 801         /* since we set the inode type below we need to mask off type
 802            to avoid strange results if bits above were corrupt */
 803         tmp_inode->i_mode &= ~S_IFMT;
 804         if (type == UNIX_FILE) {
 805                 *pobject_type = DT_REG;
 806                 tmp_inode->i_mode |= S_IFREG;
 807         } else if (type == UNIX_SYMLINK) {
 808                 *pobject_type = DT_LNK;
 809                 tmp_inode->i_mode |= S_IFLNK;
 810         } else if (type == UNIX_DIR) {
 811                 *pobject_type = DT_DIR;
 812                 tmp_inode->i_mode |= S_IFDIR;
 813         } else if (type == UNIX_CHARDEV) {
 814                 *pobject_type = DT_CHR;
 815                 tmp_inode->i_mode |= S_IFCHR;
 816                 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
 817                                 le64_to_cpu(pData->DevMinor) & MINORMASK);
 818         } else if (type == UNIX_BLOCKDEV) {
 819                 *pobject_type = DT_BLK;
 820                 tmp_inode->i_mode |= S_IFBLK;
 821                 tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
 822                                 le64_to_cpu(pData->DevMinor) & MINORMASK);
 823         } else if (type == UNIX_FIFO) {
 824                 *pobject_type = DT_FIFO;
 825                 tmp_inode->i_mode |= S_IFIFO;
 826         } else if (type == UNIX_SOCKET) {
 827                 *pobject_type = DT_SOCK;
 828                 tmp_inode->i_mode |= S_IFSOCK;
 829         } else {
 830                 /* safest to just call it a file */
 831                 *pobject_type = DT_REG;
 832                 tmp_inode->i_mode |= S_IFREG;
 833                 cFYI(1, ("unknown inode type %d", type));
 834         }
 835
 836         cFYI(DBG2, ("object type: %d", type));
 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 == cpu_to_le32(-1)) {
 951                                 /* no return info, go query for it */
 952                                 kfree(pInfo);
 953                                 goto mkdir_get_info;
 954                         }
 955 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
 956         to set uid/gid */
 957                         inc_nlink(inode);
 958                         if (pTcon->nocase)
 959                                 direntry->d_op = &cifs_ci_dentry_ops;
 960                         else
 961                                 direntry->d_op = &cifs_dentry_ops;
 962
 963                         newinode = new_inode(inode->i_sb);
 964                         if (newinode == NULL) {
 965                                 kfree(pInfo);
 966                                 goto mkdir_get_info;
 967                         }
 968                         /* Is an i_ino of zero legal? */
 969                         /* Are there sanity checks we can use to ensure that
 970                            the server is really filling in that field? */
 971                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 972                                 newinode->i_ino =
 973                                         (unsigned long)pInfo->UniqueId;
 974                         } /* note ino incremented to unique num in new_inode */
 975                         if (inode->i_sb->s_flags & MS_NOATIME)
 976                                 newinode->i_flags |= S_NOATIME | S_NOCMTIME;
 977                         newinode->i_nlink = 2;
 978
 979                         insert_inode_hash(newinode);
 980                         d_instantiate(direntry, newinode);
 981
 982                         /* we already checked in POSIXCreate whether
 983                            frame was long enough */
 984                         posix_fill_in_inode(direntry->d_inode,
 985                                         pInfo, &obj_type, 1 /* NewInode */);
 986 #ifdef CONFIG_CIFS_DEBUG2
 987                         cFYI(1, ("instantiated dentry %p %s to inode %p",
 988                                 direntry, direntry->d_name.name, newinode));
 989
 990                         if (newinode->i_nlink != 2)
 991                                 cFYI(1, ("unexpected number of links %d",
 992                                         newinode->i_nlink));
 993 #endif
 994                 }
 995                 kfree(pInfo);
 996                 goto mkdir_out;
 997         }
 998 mkdir_retry_old:
 999         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1000         rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1001                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1002         if (rc) {
1003                 cFYI(1, ("cifs_mkdir returned 0x%x", rc));
1004                 d_drop(direntry);
1005         } else {
1006 mkdir_get_info:
1007                 inc_nlink(inode);
1008                 if (pTcon->unix_ext)
1009                         rc = cifs_get_inode_info_unix(&newinode, full_path,
1010                                                       inode->i_sb, xid);
1011                 else
1012                         rc = cifs_get_inode_info(&newinode, full_path, NULL,
1013                                                  inode->i_sb, xid);
1014
1015                 if (pTcon->nocase)
1016                         direntry->d_op = &cifs_ci_dentry_ops;
1017                 else
1018                         direntry->d_op = &cifs_dentry_ops;
1019                 d_instantiate(direntry, newinode);
1020                  /* setting nlink not necessary except in cases where we
1021                   * failed to get it from the server or was set bogus */
1022                 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
1023                                 direntry->d_inode->i_nlink = 2;
1024                 if (pTcon->unix_ext) {
1025                         mode &= ~current->fs->umask;
1026                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1027                                 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
1028                                                     mode,
1029                                                     (__u64)current->fsuid,
1030                                                     (__u64)current->fsgid,
1031                                                     0 /* dev_t */,
1032                                                     cifs_sb->local_nls,
1033                                                     cifs_sb->mnt_cifs_flags &
1034                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
1035                         } else {
1036                                 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
1037                                                     mode, (__u64)-1,
1038                                                     (__u64)-1, 0 /* dev_t */,
1039                                                     cifs_sb->local_nls,
1040                                                     cifs_sb->mnt_cifs_flags &
1041                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
1042                         }
1043                 } else {
1044                         /* BB to be implemented via Windows secrty descriptors
1045                            eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
1046                                                  -1, -1, local_nls); */
1047                         if (direntry->d_inode) {
1048                                 direntry->d_inode->i_mode = mode;
1049                                 direntry->d_inode->i_mode |= S_IFDIR;
1050                                 if (cifs_sb->mnt_cifs_flags &
1051                                      CIFS_MOUNT_SET_UID) {
1052                                         direntry->d_inode->i_uid =
1053                                                 current->fsuid;
1054                                         direntry->d_inode->i_gid =
1055                                                 current->fsgid;
1056                                 }
1057                         }
1058                 }
1059         }
1060 mkdir_out:
1061         kfree(full_path);
1062         FreeXid(xid);
1063         return rc;
1064 }
1065
1066 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1067 {
1068         int rc = 0;
1069         int xid;
1070         struct cifs_sb_info *cifs_sb;
1071         struct cifsTconInfo *pTcon;
1072         char *full_path = NULL;
1073         struct cifsInodeInfo *cifsInode;
1074
1075         cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
1076
1077         xid = GetXid();
1078
1079         cifs_sb = CIFS_SB(inode->i_sb);
1080         pTcon = cifs_sb->tcon;
1081
1082         full_path = build_path_from_dentry(direntry);
1083         if (full_path == NULL) {
1084                 FreeXid(xid);
1085                 return -ENOMEM;
1086         }
1087
1088         rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1089                           cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1090
1091         if (!rc) {
1092                 drop_nlink(inode);
1093                 spin_lock(&direntry->d_inode->i_lock);
1094                 i_size_write(direntry->d_inode, 0);
1095                 clear_nlink(direntry->d_inode);
1096                 spin_unlock(&direntry->d_inode->i_lock);
1097         }
1098
1099         cifsInode = CIFS_I(direntry->d_inode);
1100         cifsInode->time = 0;    /* force revalidate to go get info when
1101                                    needed */
1102         direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1103                 current_fs_time(inode->i_sb);
1104
1105         kfree(full_path);
1106         FreeXid(xid);
1107         return rc;
1108 }
1109
1110 int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
1111         struct inode *target_inode, struct dentry *target_direntry)
1112 {
1113         char *fromName;
1114         char *toName;
1115         struct cifs_sb_info *cifs_sb_source;
1116         struct cifs_sb_info *cifs_sb_target;
1117         struct cifsTconInfo *pTcon;
1118         int xid;
1119         int rc = 0;
1120
1121         xid = GetXid();
1122
1123         cifs_sb_target = CIFS_SB(target_inode->i_sb);
1124         cifs_sb_source = CIFS_SB(source_inode->i_sb);
1125         pTcon = cifs_sb_source->tcon;
1126
1127         if (pTcon != cifs_sb_target->tcon) {
1128                 FreeXid(xid);
1129                 return -EXDEV;  /* BB actually could be allowed if same server,
1130                                    but different share.
1131                                    Might eventually add support for this */
1132         }
1133
1134         /* we already  have the rename sem so we do not need to grab it again
1135            here to protect the path integrity */
1136         fromName = build_path_from_dentry(source_direntry);
1137         toName = build_path_from_dentry(target_direntry);
1138         if ((fromName == NULL) || (toName == NULL)) {
1139                 rc = -ENOMEM;
1140                 goto cifs_rename_exit;
1141         }
1142
1143         rc = CIFSSMBRename(xid, pTcon, fromName, toName,
1144                            cifs_sb_source->local_nls,
1145                            cifs_sb_source->mnt_cifs_flags &
1146                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1147         if (rc == -EEXIST) {
1148                 /* check if they are the same file because rename of hardlinked
1149                    files is a noop */
1150                 FILE_UNIX_BASIC_INFO *info_buf_source;
1151                 FILE_UNIX_BASIC_INFO *info_buf_target;
1152
1153                 info_buf_source =
1154                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1155                 if (info_buf_source != NULL) {
1156                         info_buf_target = info_buf_source + 1;
1157                         if (pTcon->unix_ext)
1158                                 rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
1159                                         info_buf_source,
1160                                         cifs_sb_source->local_nls,
1161                                         cifs_sb_source->mnt_cifs_flags &
1162                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1163                         /* else rc is still EEXIST so will fall through to
1164                            unlink the target and retry rename */
1165                         if (rc == 0) {
1166                                 rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
1167                                                 info_buf_target,
1168                                                 cifs_sb_target->local_nls,
1169                                                 /* remap based on source sb */
1170                                                 cifs_sb_source->mnt_cifs_flags &
1171                                                     CIFS_MOUNT_MAP_SPECIAL_CHR);
1172                         }
1173                         if ((rc == 0) &&
1174                             (info_buf_source->UniqueId ==
1175                              info_buf_target->UniqueId)) {
1176                         /* do not rename since the files are hardlinked which
1177                            is a noop */
1178                         } else {
1179                         /* we either can not tell the files are hardlinked
1180                            (as with Windows servers) or files are not
1181                            hardlinked so delete the target manually before
1182                            renaming to follow POSIX rather than Windows
1183                            semantics */
1184                                 cifs_unlink(target_inode, target_direntry);
1185                                 rc = CIFSSMBRename(xid, pTcon, fromName,
1186                                                    toName,
1187                                                    cifs_sb_source->local_nls,
1188                                                    cifs_sb_source->mnt_cifs_flags
1189                                                    & CIFS_MOUNT_MAP_SPECIAL_CHR);
1190                         }
1191                         kfree(info_buf_source);
1192                 } /* if we can not get memory just leave rc as EEXIST */
1193         }
1194
1195         if (rc)
1196                 cFYI(1, ("rename rc %d", rc));
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, wbrc = 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                 wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
1331                 if (wbrc)
1332                         CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1333         }
1334         if (invalidate_inode) {
1335         /* shrink_dcache not necessary now that cifs dentry ops
1336         are exported for negative dentries */
1337 /*              if (S_ISDIR(direntry->d_inode->i_mode))
1338                         shrink_dcache_parent(direntry); */
1339                 if (S_ISREG(direntry->d_inode->i_mode)) {
1340                         if (direntry->d_inode->i_mapping)
1341                                 wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
1342                                 if (wbrc)
1343                                         CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1344                         /* may eventually have to do this for open files too */
1345                         if (list_empty(&(cifsInode->openFileList))) {
1346                                 /* changed on server - flush read ahead pages */
1347                                 cFYI(1, ("Invalidating read ahead data on "
1348                                          "closed file"));
1349                                 invalidate_remote_inode(direntry->d_inode);
1350                         }
1351                 }
1352         }
1353 /*      mutex_unlock(&direntry->d_inode->i_mutex); */
1354
1355         kfree(full_path);
1356         FreeXid(xid);
1357         return rc;
1358 }
1359
1360 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1361         struct kstat *stat)
1362 {
1363         int err = cifs_revalidate(dentry);
1364         if (!err) {
1365                 generic_fillattr(dentry->d_inode, stat);
1366                 stat->blksize = CIFS_MAX_MSGSIZE;
1367         }
1368         return err;
1369 }
1370
1371 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1372 {
1373         pgoff_t index = from >> PAGE_CACHE_SHIFT;
1374         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1375         struct page *page;
1376         int rc = 0;
1377
1378         page = grab_cache_page(mapping, index);
1379         if (!page)
1380                 return -ENOMEM;
1381
1382         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1383         unlock_page(page);
1384         page_cache_release(page);
1385         return rc;
1386 }
1387
1388 static int cifs_vmtruncate(struct inode *inode, loff_t offset)
1389 {
1390         struct address_space *mapping = inode->i_mapping;
1391         unsigned long limit;
1392
1393         spin_lock(&inode->i_lock);
1394         if (inode->i_size < offset)
1395                 goto do_expand;
1396         /*
1397          * truncation of in-use swapfiles is disallowed - it would cause
1398          * subsequent swapout to scribble on the now-freed blocks.
1399          */
1400         if (IS_SWAPFILE(inode)) {
1401                 spin_unlock(&inode->i_lock);
1402                 goto out_busy;
1403         }
1404         i_size_write(inode, offset);
1405         spin_unlock(&inode->i_lock);
1406         /*
1407          * unmap_mapping_range is called twice, first simply for efficiency
1408          * so that truncate_inode_pages does fewer single-page unmaps. However
1409          * after this first call, and before truncate_inode_pages finishes,
1410          * it is possible for private pages to be COWed, which remain after
1411          * truncate_inode_pages finishes, hence the second unmap_mapping_range
1412          * call must be made for correctness.
1413          */
1414         unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1415         truncate_inode_pages(mapping, offset);
1416         unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1417         goto out_truncate;
1418
1419 do_expand:
1420         limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1421         if (limit != RLIM_INFINITY && offset > limit) {
1422                 spin_unlock(&inode->i_lock);
1423                 goto out_sig;
1424         }
1425         if (offset > inode->i_sb->s_maxbytes) {
1426                 spin_unlock(&inode->i_lock);
1427                 goto out_big;
1428         }
1429         i_size_write(inode, offset);
1430         spin_unlock(&inode->i_lock);
1431 out_truncate:
1432         if (inode->i_op && inode->i_op->truncate)
1433                 inode->i_op->truncate(inode);
1434         return 0;
1435 out_sig:
1436         send_sig(SIGXFSZ, current, 0);
1437 out_big:
1438         return -EFBIG;
1439 out_busy:
1440         return -ETXTBSY;
1441 }
1442
1443 int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1444 {
1445         int xid;
1446         struct cifs_sb_info *cifs_sb;
1447         struct cifsTconInfo *pTcon;
1448         char *full_path = NULL;
1449         int rc = -EACCES;
1450         struct cifsFileInfo *open_file = NULL;
1451         FILE_BASIC_INFO time_buf;
1452         int set_time = FALSE;
1453         int set_dosattr = FALSE;
1454         __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
1455         __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
1456         __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
1457         struct cifsInodeInfo *cifsInode;
1458
1459         xid = GetXid();
1460
1461         cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
1462                  direntry->d_name.name, attrs->ia_valid));
1463
1464         cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
1465         pTcon = cifs_sb->tcon;
1466
1467         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1468                 /* check if we have permission to change attrs */
1469                 rc = inode_change_ok(direntry->d_inode, attrs);
1470                 if (rc < 0) {
1471                         FreeXid(xid);
1472                         return rc;
1473                 } else
1474                         rc = 0;
1475         }
1476
1477         full_path = build_path_from_dentry(direntry);
1478         if (full_path == NULL) {
1479                 FreeXid(xid);
1480                 return -ENOMEM;
1481         }
1482         cifsInode = CIFS_I(direntry->d_inode);
1483
1484         /* BB check if we need to refresh inode from server now ? BB */
1485
1486         if (attrs->ia_valid & ATTR_SIZE) {
1487                 /*
1488                    Flush data before changing file size on server. If the
1489                    flush returns error, store it to report later and continue.
1490                    BB: This should be smarter. Why bother flushing pages that
1491                    will be truncated anyway? Also, should we error out here if
1492                    the flush returns error?
1493                  */
1494                 rc = filemap_write_and_wait(direntry->d_inode->i_mapping);
1495                 if (rc != 0) {
1496                         CIFS_I(direntry->d_inode)->write_behind_rc = rc;
1497                         rc = 0;
1498                 }
1499
1500                 /* To avoid spurious oplock breaks from server, in the case of
1501                    inodes that we already have open, avoid doing path based
1502                    setting of file size if we can do it by handle.
1503                    This keeps our caching token (oplock) and avoids timeouts
1504                    when the local oplock break takes longer to flush
1505                    writebehind data than the SMB timeout for the SetPathInfo
1506                    request would allow */
1507
1508                 open_file = find_writable_file(cifsInode);
1509                 if (open_file) {
1510                         __u16 nfid = open_file->netfid;
1511                         __u32 npid = open_file->pid;
1512                         rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
1513                                                 nfid, npid, FALSE);
1514                         atomic_dec(&open_file->wrtPending);
1515                         cFYI(1, ("SetFSize for attrs rc = %d", rc));
1516                         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1517                                 unsigned int bytes_written;
1518                                 rc = CIFSSMBWrite(xid, pTcon,
1519                                                   nfid, 0, attrs->ia_size,
1520                                                   &bytes_written, NULL, NULL,
1521                                                   1 /* 45 seconds */);
1522                                 cFYI(1, ("Wrt seteof rc %d", rc));
1523                         }
1524                 } else
1525                         rc = -EINVAL;
1526
1527                 if (rc != 0) {
1528                         /* Set file size by pathname rather than by handle
1529                            either because no valid, writeable file handle for
1530                            it was found or because there was an error setting
1531                            it by handle */
1532                         rc = CIFSSMBSetEOF(xid, pTcon, full_path,
1533                                            attrs->ia_size, FALSE,
1534                                            cifs_sb->local_nls,
1535                                            cifs_sb->mnt_cifs_flags &
1536                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1537                         cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1538                         if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1539                                 __u16 netfid;
1540                                 int oplock = FALSE;
1541
1542                                 rc = SMBLegacyOpen(xid, pTcon, full_path,
1543                                         FILE_OPEN,
1544                                         SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1545                                         CREATE_NOT_DIR, &netfid, &oplock,
1546                                         NULL, cifs_sb->local_nls,
1547                                         cifs_sb->mnt_cifs_flags &
1548                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1549                                 if (rc == 0) {
1550                                         unsigned int bytes_written;
1551                                         rc = CIFSSMBWrite(xid, pTcon,
1552                                                         netfid, 0,
1553                                                         attrs->ia_size,
1554                                                         &bytes_written, NULL,
1555                                                         NULL, 1 /* 45 sec */);
1556                                         cFYI(1, ("wrt seteof rc %d", rc));
1557                                         CIFSSMBClose(xid, pTcon, netfid);
1558                                 }
1559
1560                         }
1561                 }
1562
1563                 /* Server is ok setting allocation size implicitly - no need
1564                    to call:
1565                 CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE,
1566                          cifs_sb->local_nls);
1567                    */
1568
1569                 if (rc == 0) {
1570                         rc = cifs_vmtruncate(direntry->d_inode, attrs->ia_size);
1571                         cifs_truncate_page(direntry->d_inode->i_mapping,
1572                                            direntry->d_inode->i_size);
1573                 } else
1574                         goto cifs_setattr_exit;
1575         }
1576         if (attrs->ia_valid & ATTR_UID) {
1577                 cFYI(1, ("UID changed to %d", attrs->ia_uid));
1578                 uid = attrs->ia_uid;
1579         }
1580         if (attrs->ia_valid & ATTR_GID) {
1581                 cFYI(1, ("GID changed to %d", attrs->ia_gid));
1582                 gid = attrs->ia_gid;
1583         }
1584
1585         time_buf.Attributes = 0;
1586
1587         /* skip mode change if it's just for clearing setuid/setgid */
1588         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1589                 attrs->ia_valid &= ~ATTR_MODE;
1590
1591         if (attrs->ia_valid & ATTR_MODE) {
1592                 cFYI(1, ("Mode changed to 0x%x", attrs->ia_mode));
1593                 mode = attrs->ia_mode;
1594         }
1595
1596         if ((pTcon->unix_ext)
1597             && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
1598                 rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
1599                                          0 /* dev_t */, cifs_sb->local_nls,
1600                                          cifs_sb->mnt_cifs_flags &
1601                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1602         else if (attrs->ia_valid & ATTR_MODE) {
1603                 rc = 0;
1604 #ifdef CONFIG_CIFS_EXPERIMENTAL
1605                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1606                         rc = mode_to_acl(direntry->d_inode, full_path, mode);
1607                 else if ((mode & S_IWUGO) == 0) {
1608 #else
1609                 if ((mode & S_IWUGO) == 0) {
1610 #endif
1611                         /* not writeable */
1612                         if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1613                                 set_dosattr = TRUE;
1614                                 time_buf.Attributes =
1615                                         cpu_to_le32(cifsInode->cifsAttrs |
1616                                                     ATTR_READONLY);
1617                         }
1618                 } else if (cifsInode->cifsAttrs & ATTR_READONLY) {
1619                         /* If file is readonly on server, we would
1620                         not be able to write to it - so if any write
1621                         bit is enabled for user or group or other we
1622                         need to at least try to remove r/o dos attr */
1623                         set_dosattr = TRUE;
1624                         time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
1625                                             (~ATTR_READONLY));
1626                         /* Windows ignores set to zero */
1627                         if (time_buf.Attributes == 0)
1628                                 time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
1629                 }
1630 #ifdef CONFIG_CIFS_EXPERIMENTAL
1631                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1632                         mode_to_acl(direntry->d_inode, full_path, mode);
1633 #endif
1634         }
1635
1636         if (attrs->ia_valid & ATTR_ATIME) {
1637                 set_time = TRUE;
1638                 time_buf.LastAccessTime =
1639                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1640         } else
1641                 time_buf.LastAccessTime = 0;
1642
1643         if (attrs->ia_valid & ATTR_MTIME) {
1644                 set_time = TRUE;
1645                 time_buf.LastWriteTime =
1646                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1647         } else
1648                 time_buf.LastWriteTime = 0;
1649         /* Do not set ctime explicitly unless other time
1650            stamps are changed explicitly (i.e. by utime()
1651            since we would then have a mix of client and
1652            server times */
1653
1654         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1655                 set_time = TRUE;
1656                 /* Although Samba throws this field away
1657                 it may be useful to Windows - but we do
1658                 not want to set ctime unless some other
1659                 timestamp is changing */
1660                 cFYI(1, ("CIFS - CTIME changed"));
1661                 time_buf.ChangeTime =
1662                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1663         } else
1664                 time_buf.ChangeTime = 0;
1665
1666         if (set_time || set_dosattr) {
1667                 time_buf.CreationTime = 0;      /* do not change */
1668                 /* In the future we should experiment - try setting timestamps
1669                    via Handle (SetFileInfo) instead of by path */
1670                 if (!(pTcon->ses->flags & CIFS_SES_NT4))
1671                         rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
1672                                              cifs_sb->local_nls,
1673                                              cifs_sb->mnt_cifs_flags &
1674                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1675                 else
1676                         rc = -EOPNOTSUPP;
1677
1678                 if (rc == -EOPNOTSUPP) {
1679                         int oplock = FALSE;
1680                         __u16 netfid;
1681
1682                         cFYI(1, ("calling SetFileInfo since SetPathInfo for "
1683                                  "times not supported by this server"));
1684                         /* BB we could scan to see if we already have it open
1685                            and pass in pid of opener to function */
1686                         rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1687                                          SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1688                                          CREATE_NOT_DIR, &netfid, &oplock,
1689                                          NULL, cifs_sb->local_nls,
1690                                          cifs_sb->mnt_cifs_flags &
1691                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
1692                         if (rc == 0) {
1693                                 rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
1694                                                          netfid);
1695                                 CIFSSMBClose(xid, pTcon, netfid);
1696                         } else {
1697                         /* BB For even older servers we could convert time_buf
1698                            into old DOS style which uses two second
1699                            granularity */
1700
1701                         /* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
1702                                         &time_buf, cifs_sb->local_nls); */
1703                         }
1704                 }
1705                 /* Even if error on time set, no sense failing the call if
1706                 the server would set the time to a reasonable value anyway,
1707                 and this check ensures that we are not being called from
1708                 sys_utimes in which case we ought to fail the call back to
1709                 the user when the server rejects the call */
1710                 if ((rc) && (attrs->ia_valid &
1711                          (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
1712                         rc = 0;
1713         }
1714
1715         /* do not need local check to inode_check_ok since the server does
1716            that */
1717         if (!rc)
1718                 rc = inode_setattr(direntry->d_inode, attrs);
1719 cifs_setattr_exit:
1720         kfree(full_path);
1721         FreeXid(xid);
1722         return rc;
1723 }
1724
1725 #if 0
1726 void cifs_delete_inode(struct inode *inode)
1727 {
1728         cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
1729         /* may have to add back in if and when safe distributed caching of
1730            directories added e.g. via FindNotify */
1731 }
1732 #endif