SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/cifs/inode.c

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