fs/cifs/file.c

   1 /*
   2  *   fs/cifs/file.c
   3  *
   4  *   vfs operations that deal with files
   5  *
   6  *   Copyright (C) International Business Machines  Corp., 2002,2007
   7  *   Author(s): Steve French (sfrench@us.ibm.com)
   8  *              Jeremy Allison (jra@samba.org)
   9  *
  10  *   This library is free software; you can redistribute it and/or modify
  11  *   it under the terms of the GNU Lesser General Public License as published
  12  *   by the Free Software Foundation; either version 2.1 of the License, or
  13  *   (at your option) any later version.
  14  *
  15  *   This library is distributed in the hope that it will be useful,
  16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  18  *   the GNU Lesser General Public License for more details.
  19  *
  20  *   You should have received a copy of the GNU Lesser General Public License
  21  *   along with this library; if not, write to the Free Software
  22  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23  */
  24 #include <linux/fs.h>
  25 #include <linux/backing-dev.h>
  26 #include <linux/stat.h>
  27 #include <linux/fcntl.h>
  28 #include <linux/pagemap.h>
  29 #include <linux/pagevec.h>
  30 #include <linux/writeback.h>
  31 #include <linux/task_io_accounting_ops.h>
  32 #include <linux/delay.h>
  33 #include <asm/div64.h>
  34 #include "cifsfs.h"
  35 #include "cifspdu.h"
  36 #include "cifsglob.h"
  37 #include "cifsproto.h"
  38 #include "cifs_unicode.h"
  39 #include "cifs_debug.h"
  40 #include "cifs_fs_sb.h"
  41
  42 static inline struct cifsFileInfo *cifs_init_private(
  43         struct cifsFileInfo *private_data, struct inode *inode,
  44         struct file *file, __u16 netfid)
  45 {
  46         memset(private_data, 0, sizeof(struct cifsFileInfo));
  47         private_data->netfid = netfid;
  48         private_data->pid = current->tgid;
  49         init_MUTEX(&private_data->fh_sem);
  50         mutex_init(&private_data->lock_mutex);
  51         INIT_LIST_HEAD(&private_data->llist);
  52         private_data->pfile = file; /* needed for writepage */
  53         private_data->pInode = inode;
  54         private_data->invalidHandle = FALSE;
  55         private_data->closePend = FALSE;
  56         /* we have to track num writers to the inode, since writepages
  57         does not tell us which handle the write is for so there can
  58         be a close (overlapping with write) of the filehandle that
  59         cifs_writepages chose to use */
  60         atomic_set(&private_data->wrtPending, 0);
  61
  62         return private_data;
  63 }
  64
  65 static inline int cifs_convert_flags(unsigned int flags)
  66 {
  67         if ((flags & O_ACCMODE) == O_RDONLY)
  68                 return GENERIC_READ;
  69         else if ((flags & O_ACCMODE) == O_WRONLY)
  70                 return GENERIC_WRITE;
  71         else if ((flags & O_ACCMODE) == O_RDWR) {
  72                 /* GENERIC_ALL is too much permission to request
  73                    can cause unnecessary access denied on create */
  74                 /* return GENERIC_ALL; */
  75                 return (GENERIC_READ | GENERIC_WRITE);
  76         }
  77
  78         return 0x20197;
  79 }
  80
  81 static inline int cifs_get_disposition(unsigned int flags)
  82 {
  83         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
  84                 return FILE_CREATE;
  85         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
  86                 return FILE_OVERWRITE_IF;
  87         else if ((flags & O_CREAT) == O_CREAT)
  88                 return FILE_OPEN_IF;
  89         else if ((flags & O_TRUNC) == O_TRUNC)
  90                 return FILE_OVERWRITE;
  91         else
  92                 return FILE_OPEN;
  93 }
  94
  95 /* all arguments to this function must be checked for validity in caller */
  96 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
  97         struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
  98         struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
  99         char *full_path, int xid)
 100 {
 101         struct timespec temp;
 102         int rc;
 103
 104         /* want handles we can use to read with first
 105            in the list so we do not have to walk the
 106            list to search for one in prepare_write */
 107         if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
 108                 list_add_tail(&pCifsFile->flist,
 109                               &pCifsInode->openFileList);
 110         } else {
 111                 list_add(&pCifsFile->flist,
 112                          &pCifsInode->openFileList);
 113         }
 114         write_unlock(&GlobalSMBSeslock);
 115         if (pCifsInode->clientCanCacheRead) {
 116                 /* we have the inode open somewhere else
 117                    no need to discard cache data */
 118                 goto client_can_cache;
 119         }
 120
 121         /* BB need same check in cifs_create too? */
 122         /* if not oplocked, invalidate inode pages if mtime or file
 123            size changed */
 124         temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
 125         if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
 126                            (file->f_path.dentry->d_inode->i_size ==
 127                             (loff_t)le64_to_cpu(buf->EndOfFile))) {
 128                 cFYI(1, ("inode unchanged on server"));
 129         } else {
 130                 if (file->f_path.dentry->d_inode->i_mapping) {
 131                 /* BB no need to lock inode until after invalidate
 132                    since namei code should already have it locked? */
 133                         filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
 134                 }
 135                 cFYI(1, ("invalidating remote inode since open detected it "
 136                          "changed"));
 137                 invalidate_remote_inode(file->f_path.dentry->d_inode);
 138         }
 139
 140 client_can_cache:
 141         if (pTcon->unix_ext)
 142                 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
 143                         full_path, inode->i_sb, xid);
 144         else
 145                 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
 146                         full_path, buf, inode->i_sb, xid);
 147
 148         if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
 149                 pCifsInode->clientCanCacheAll = TRUE;
 150                 pCifsInode->clientCanCacheRead = TRUE;
 151                 cFYI(1, ("Exclusive Oplock granted on inode %p",
 152                          file->f_path.dentry->d_inode));
 153         } else if ((*oplock & 0xF) == OPLOCK_READ)
 154                 pCifsInode->clientCanCacheRead = TRUE;
 155
 156         return rc;
 157 }
 158
 159 int cifs_open(struct inode *inode, struct file *file)
 160 {
 161         int rc = -EACCES;
 162         int xid, oplock;
 163         struct cifs_sb_info *cifs_sb;
 164         struct cifsTconInfo *pTcon;
 165         struct cifsFileInfo *pCifsFile;
 166         struct cifsInodeInfo *pCifsInode;
 167         struct list_head *tmp;
 168         char *full_path = NULL;
 169         int desiredAccess;
 170         int disposition;
 171         __u16 netfid;
 172         FILE_ALL_INFO *buf = NULL;
 173
 174         xid = GetXid();
 175
 176         cifs_sb = CIFS_SB(inode->i_sb);
 177         pTcon = cifs_sb->tcon;
 178
 179         if (file->f_flags & O_CREAT) {
 180                 /* search inode for this file and fill in file->private_data */
 181                 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
 182                 read_lock(&GlobalSMBSeslock);
 183                 list_for_each(tmp, &pCifsInode->openFileList) {
 184                         pCifsFile = list_entry(tmp, struct cifsFileInfo,
 185                                                flist);
 186                         if ((pCifsFile->pfile == NULL) &&
 187                             (pCifsFile->pid == current->tgid)) {
 188                                 /* mode set in cifs_create */
 189
 190                                 /* needed for writepage */
 191                                 pCifsFile->pfile = file;
 192
 193                                 file->private_data = pCifsFile;
 194                                 break;
 195                         }
 196                 }
 197                 read_unlock(&GlobalSMBSeslock);
 198                 if (file->private_data != NULL) {
 199                         rc = 0;
 200                         FreeXid(xid);
 201                         return rc;
 202                 } else {
 203                         if (file->f_flags & O_EXCL)
 204                                 cERROR(1, ("could not find file instance for "
 205                                            "new file %p", file));
 206                 }
 207         }
 208
 209         full_path = build_path_from_dentry(file->f_path.dentry);
 210         if (full_path == NULL) {
 211                 FreeXid(xid);
 212                 return -ENOMEM;
 213         }
 214
 215         cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
 216                  inode, file->f_flags, full_path));
 217         desiredAccess = cifs_convert_flags(file->f_flags);
 218
 219 /*********************************************************************
 220  *  open flag mapping table:
 221  *
 222  *      POSIX Flag            CIFS Disposition
 223  *      ----------            ----------------
 224  *      O_CREAT               FILE_OPEN_IF
 225  *      O_CREAT | O_EXCL      FILE_CREATE
 226  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 227  *      O_TRUNC               FILE_OVERWRITE
 228  *      none of the above     FILE_OPEN
 229  *
 230  *      Note that there is not a direct match between disposition
 231  *      FILE_SUPERSEDE (ie create whether or not file exists although
 232  *      O_CREAT | O_TRUNC is similar but truncates the existing
 233  *      file rather than creating a new file as FILE_SUPERSEDE does
 234  *      (which uses the attributes / metadata passed in on open call)
 235  *?
 236  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 237  *?  and the read write flags match reasonably.  O_LARGEFILE
 238  *?  is irrelevant because largefile support is always used
 239  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 240  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 241  *********************************************************************/
 242
 243         disposition = cifs_get_disposition(file->f_flags);
 244
 245         if (oplockEnabled)
 246                 oplock = REQ_OPLOCK;
 247         else
 248                 oplock = FALSE;
 249
 250         /* BB pass O_SYNC flag through on file attributes .. BB */
 251
 252         /* Also refresh inode by passing in file_info buf returned by SMBOpen
 253            and calling get_inode_info with returned buf (at least helps
 254            non-Unix server case) */
 255
 256         /* BB we can not do this if this is the second open of a file
 257            and the first handle has writebehind data, we might be
 258            able to simply do a filemap_fdatawrite/filemap_fdatawait first */
 259         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 260         if (!buf) {
 261                 rc = -ENOMEM;
 262                 goto out;
 263         }
 264
 265         if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
 266                 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
 267                          desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
 268                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 269                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
 270         else
 271                 rc = -EIO; /* no NT SMB support fall into legacy open below */
 272
 273         if (rc == -EIO) {
 274                 /* Old server, try legacy style OpenX */
 275                 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
 276                         desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
 277                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 278                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
 279         }
 280         if (rc) {
 281                 cFYI(1, ("cifs_open returned 0x%x", rc));
 282                 goto out;
 283         }
 284         file->private_data =
 285                 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 286         if (file->private_data == NULL) {
 287                 rc = -ENOMEM;
 288                 goto out;
 289         }
 290         pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
 291         write_lock(&GlobalSMBSeslock);
 292         list_add(&pCifsFile->tlist, &pTcon->openFileList);
 293
 294         pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
 295         if (pCifsInode) {
 296                 rc = cifs_open_inode_helper(inode, file, pCifsInode,
 297                                             pCifsFile, pTcon,
 298                                             &oplock, buf, full_path, xid);
 299         } else {
 300                 write_unlock(&GlobalSMBSeslock);
 301         }
 302
 303         if (oplock & CIFS_CREATE_ACTION) {
 304                 /* time to set mode which we can not set earlier due to
 305                    problems creating new read-only files */
 306                 if (pTcon->unix_ext) {
 307                         CIFSSMBUnixSetPerms(xid, pTcon, full_path,
 308                                             inode->i_mode,
 309                                             (__u64)-1, (__u64)-1, 0 /* dev */,
 310                                             cifs_sb->local_nls,
 311                                             cifs_sb->mnt_cifs_flags &
 312                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 313                 } else {
 314                         /* BB implement via Windows security descriptors eg
 315                            CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
 316                                               -1, -1, local_nls);
 317                            in the meantime could set r/o dos attribute when
 318                            perms are eg: mode & 0222 == 0 */
 319                 }
 320         }
 321
 322 out:
 323         kfree(buf);
 324         kfree(full_path);
 325         FreeXid(xid);
 326         return rc;
 327 }
 328
 329 /* Try to reacquire byte range locks that were released when session */
 330 /* to server was lost */
 331 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
 332 {
 333         int rc = 0;
 334
 335 /* BB list all locks open on this file and relock */
 336
 337         return rc;
 338 }
 339
 340 static int cifs_reopen_file(struct file *file, int can_flush)
 341 {
 342         int rc = -EACCES;
 343         int xid, oplock;
 344         struct cifs_sb_info *cifs_sb;
 345         struct cifsTconInfo *pTcon;
 346         struct cifsFileInfo *pCifsFile;
 347         struct cifsInodeInfo *pCifsInode;
 348         struct inode *inode;
 349         char *full_path = NULL;
 350         int desiredAccess;
 351         int disposition = FILE_OPEN;
 352         __u16 netfid;
 353
 354         if (file->private_data) {
 355                 pCifsFile = (struct cifsFileInfo *)file->private_data;
 356         } else
 357                 return -EBADF;
 358
 359         xid = GetXid();
 360         down(&pCifsFile->fh_sem);
 361         if (pCifsFile->invalidHandle == FALSE) {
 362                 up(&pCifsFile->fh_sem);
 363                 FreeXid(xid);
 364                 return 0;
 365         }
 366
 367         if (file->f_path.dentry == NULL) {
 368                 cERROR(1, ("no valid name if dentry freed"));
 369                 dump_stack();
 370                 rc = -EBADF;
 371                 goto reopen_error_exit;
 372         }
 373
 374         inode = file->f_path.dentry->d_inode;
 375         if (inode == NULL) {
 376                 cERROR(1, ("inode not valid"));
 377                 dump_stack();
 378                 rc = -EBADF;
 379                 goto reopen_error_exit;
 380         }
 381
 382         cifs_sb = CIFS_SB(inode->i_sb);
 383         pTcon = cifs_sb->tcon;
 384
 385 /* can not grab rename sem here because various ops, including
 386    those that already have the rename sem can end up causing writepage
 387    to get called and if the server was down that means we end up here,
 388    and we can never tell if the caller already has the rename_sem */
 389         full_path = build_path_from_dentry(file->f_path.dentry);
 390         if (full_path == NULL) {
 391                 rc = -ENOMEM;
 392 reopen_error_exit:
 393                 up(&pCifsFile->fh_sem);
 394                 FreeXid(xid);
 395                 return rc;
 396         }
 397
 398         cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
 399                  inode, file->f_flags, full_path));
 400         desiredAccess = cifs_convert_flags(file->f_flags);
 401
 402         if (oplockEnabled)
 403                 oplock = REQ_OPLOCK;
 404         else
 405                 oplock = FALSE;
 406
 407         /* Can not refresh inode by passing in file_info buf to be returned
 408            by SMBOpen and then calling get_inode_info with returned buf
 409            since file might have write behind data that needs to be flushed
 410            and server version of file size can be stale. If we knew for sure
 411            that inode was not dirty locally we could do this */
 412
 413         rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
 414                          CREATE_NOT_DIR, &netfid, &oplock, NULL,
 415                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 416                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 417         if (rc) {
 418                 up(&pCifsFile->fh_sem);
 419                 cFYI(1, ("cifs_open returned 0x%x", rc));
 420                 cFYI(1, ("oplock: %d", oplock));
 421         } else {
 422                 pCifsFile->netfid = netfid;
 423                 pCifsFile->invalidHandle = FALSE;
 424                 up(&pCifsFile->fh_sem);
 425                 pCifsInode = CIFS_I(inode);
 426                 if (pCifsInode) {
 427                         if (can_flush) {
 428                                 filemap_write_and_wait(inode->i_mapping);
 429                         /* temporarily disable caching while we
 430                            go to server to get inode info */
 431                                 pCifsInode->clientCanCacheAll = FALSE;
 432                                 pCifsInode->clientCanCacheRead = FALSE;
 433                                 if (pTcon->unix_ext)
 434                                         rc = cifs_get_inode_info_unix(&inode,
 435                                                 full_path, inode->i_sb, xid);
 436                                 else
 437                                         rc = cifs_get_inode_info(&inode,
 438                                                 full_path, NULL, inode->i_sb,
 439                                                 xid);
 440                         } /* else we are writing out data to server already
 441                              and could deadlock if we tried to flush data, and
 442                              since we do not know if we have data that would
 443                              invalidate the current end of file on the server
 444                              we can not go to the server to get the new inod
 445                              info */
 446                         if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
 447                                 pCifsInode->clientCanCacheAll = TRUE;
 448                                 pCifsInode->clientCanCacheRead = TRUE;
 449                                 cFYI(1, ("Exclusive Oplock granted on inode %p",
 450                                          file->f_path.dentry->d_inode));
 451                         } else if ((oplock & 0xF) == OPLOCK_READ) {
 452                                 pCifsInode->clientCanCacheRead = TRUE;
 453                                 pCifsInode->clientCanCacheAll = FALSE;
 454                         } else {
 455                                 pCifsInode->clientCanCacheRead = FALSE;
 456                                 pCifsInode->clientCanCacheAll = FALSE;
 457                         }
 458                         cifs_relock_file(pCifsFile);
 459                 }
 460         }
 461
 462         kfree(full_path);
 463         FreeXid(xid);
 464         return rc;
 465 }
 466
 467 int cifs_close(struct inode *inode, struct file *file)
 468 {
 469         int rc = 0;
 470         int xid, timeout;
 471         struct cifs_sb_info *cifs_sb;
 472         struct cifsTconInfo *pTcon;
 473         struct cifsFileInfo *pSMBFile =
 474                 (struct cifsFileInfo *)file->private_data;
 475
 476         xid = GetXid();
 477
 478         cifs_sb = CIFS_SB(inode->i_sb);
 479         pTcon = cifs_sb->tcon;
 480         if (pSMBFile) {
 481                 struct cifsLockInfo *li, *tmp;
 482
 483                 pSMBFile->closePend = TRUE;
 484                 if (pTcon) {
 485                         /* no sense reconnecting to close a file that is
 486                            already closed */
 487                         if (pTcon->tidStatus != CifsNeedReconnect) {
 488                                 timeout = 2;
 489                                 while ((atomic_read(&pSMBFile->wrtPending) != 0)
 490                                         && (timeout <= 2048)) {
 491                                         /* Give write a better chance to get to
 492                                         server ahead of the close.  We do not
 493                                         want to add a wait_q here as it would
 494                                         increase the memory utilization as
 495                                         the struct would be in each open file,
 496                                         but this should give enough time to
 497                                         clear the socket */
 498 #ifdef CONFIG_CIFS_DEBUG2
 499                                         cFYI(1, ("close delay, write pending"));
 500 #endif /* DEBUG2 */
 501                                         msleep(timeout);
 502                                         timeout *= 4;
 503                                 }
 504                                 if (atomic_read(&pSMBFile->wrtPending))
 505                                         cERROR(1,
 506                                                 ("close with pending writes"));
 507                                 rc = CIFSSMBClose(xid, pTcon,
 508                                                   pSMBFile->netfid);
 509                         }
 510                 }
 511
 512                 /* Delete any outstanding lock records.
 513                    We'll lose them when the file is closed anyway. */
 514                 mutex_lock(&pSMBFile->lock_mutex);
 515                 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
 516                         list_del(&li->llist);
 517                         kfree(li);
 518                 }
 519                 mutex_unlock(&pSMBFile->lock_mutex);
 520
 521                 write_lock(&GlobalSMBSeslock);
 522                 list_del(&pSMBFile->flist);
 523                 list_del(&pSMBFile->tlist);
 524                 write_unlock(&GlobalSMBSeslock);
 525                 timeout = 10;
 526                 /* We waited above to give the SMBWrite a chance to issue
 527                    on the wire (so we do not get SMBWrite returning EBADF
 528                    if writepages is racing with close.  Note that writepages
 529                    does not specify a file handle, so it is possible for a file
 530                    to be opened twice, and the application close the "wrong"
 531                    file handle - in these cases we delay long enough to allow
 532                    the SMBWrite to get on the wire before the SMB Close.
 533                    We allow total wait here over 45 seconds, more than
 534                    oplock break time, and more than enough to allow any write
 535                    to complete on the server, or to time out on the client */
 536                 while ((atomic_read(&pSMBFile->wrtPending) != 0)
 537                                 && (timeout <= 50000)) {
 538                         cERROR(1, ("writes pending, delay free of handle"));
 539                         msleep(timeout);
 540                         timeout *= 8;
 541                 }
 542                 kfree(pSMBFile->search_resume_name);
 543                 kfree(file->private_data);
 544                 file->private_data = NULL;
 545         } else
 546                 rc = -EBADF;
 547
 548         if (list_empty(&(CIFS_I(inode)->openFileList))) {
 549                 cFYI(1, ("closing last open instance for inode %p", inode));
 550                 /* if the file is not open we do not know if we can cache info
 551                    on this inode, much less write behind and read ahead */
 552                 CIFS_I(inode)->clientCanCacheRead = FALSE;
 553                 CIFS_I(inode)->clientCanCacheAll  = FALSE;
 554         }
 555         if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
 556                 rc = CIFS_I(inode)->write_behind_rc;
 557         FreeXid(xid);
 558         return rc;
 559 }
 560
 561 int cifs_closedir(struct inode *inode, struct file *file)
 562 {
 563         int rc = 0;
 564         int xid;
 565         struct cifsFileInfo *pCFileStruct =
 566             (struct cifsFileInfo *)file->private_data;
 567         char *ptmp;
 568
 569         cFYI(1, ("Closedir inode = 0x%p", inode));
 570
 571         xid = GetXid();
 572
 573         if (pCFileStruct) {
 574                 struct cifsTconInfo *pTcon;
 575                 struct cifs_sb_info *cifs_sb =
 576                         CIFS_SB(file->f_path.dentry->d_sb);
 577
 578                 pTcon = cifs_sb->tcon;
 579
 580                 cFYI(1, ("Freeing private data in close dir"));
 581                 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
 582                    (pCFileStruct->invalidHandle == FALSE)) {
 583                         pCFileStruct->invalidHandle = TRUE;
 584                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 585                         cFYI(1, ("Closing uncompleted readdir with rc %d",
 586                                  rc));
 587                         /* not much we can do if it fails anyway, ignore rc */
 588                         rc = 0;
 589                 }
 590                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 591                 if (ptmp) {
 592                         cFYI(1, ("closedir free smb buf in srch struct"));
 593                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 594                         if (pCFileStruct->srch_inf.smallBuf)
 595                                 cifs_small_buf_release(ptmp);
 596                         else
 597                                 cifs_buf_release(ptmp);
 598                 }
 599                 ptmp = pCFileStruct->search_resume_name;
 600                 if (ptmp) {
 601                         cFYI(1, ("closedir free resume name"));
 602                         pCFileStruct->search_resume_name = NULL;
 603                         kfree(ptmp);
 604                 }
 605                 kfree(file->private_data);
 606                 file->private_data = NULL;
 607         }
 608         /* BB can we lock the filestruct while this is going on? */
 609         FreeXid(xid);
 610         return rc;
 611 }
 612
 613 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
 614                                 __u64 offset, __u8 lockType)
 615 {
 616         struct cifsLockInfo *li =
 617                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 618         if (li == NULL)
 619                 return -ENOMEM;
 620         li->offset = offset;
 621         li->length = len;
 622         li->type = lockType;
 623         mutex_lock(&fid->lock_mutex);
 624         list_add(&li->llist, &fid->llist);
 625         mutex_unlock(&fid->lock_mutex);
 626         return 0;
 627 }
 628
 629 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
 630 {
 631         int rc, xid;
 632         __u32 numLock = 0;
 633         __u32 numUnlock = 0;
 634         __u64 length;
 635         int wait_flag = FALSE;
 636         struct cifs_sb_info *cifs_sb;
 637         struct cifsTconInfo *pTcon;
 638         __u16 netfid;
 639         __u8 lockType = LOCKING_ANDX_LARGE_FILES;
 640         int posix_locking;
 641
 642         length = 1 + pfLock->fl_end - pfLock->fl_start;
 643         rc = -EACCES;
 644         xid = GetXid();
 645
 646         cFYI(1, ("Lock parm: 0x%x flockflags: "
 647                  "0x%x flocktype: 0x%x start: %lld end: %lld",
 648                 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
 649                 pfLock->fl_end));
 650
 651         if (pfLock->fl_flags & FL_POSIX)
 652                 cFYI(1, ("Posix"));
 653         if (pfLock->fl_flags & FL_FLOCK)
 654                 cFYI(1, ("Flock"));
 655         if (pfLock->fl_flags & FL_SLEEP) {
 656                 cFYI(1, ("Blocking lock"));
 657                 wait_flag = TRUE;
 658         }
 659         if (pfLock->fl_flags & FL_ACCESS)
 660                 cFYI(1, ("Process suspended by mandatory locking - "
 661                          "not implemented yet"));
 662         if (pfLock->fl_flags & FL_LEASE)
 663                 cFYI(1, ("Lease on file - not implemented yet"));
 664         if (pfLock->fl_flags &
 665             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
 666                 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
 667
 668         if (pfLock->fl_type == F_WRLCK) {
 669                 cFYI(1, ("F_WRLCK "));
 670                 numLock = 1;
 671         } else if (pfLock->fl_type == F_UNLCK) {
 672                 cFYI(1, ("F_UNLCK"));
 673                 numUnlock = 1;
 674                 /* Check if unlock includes more than
 675                 one lock range */
 676         } else if (pfLock->fl_type == F_RDLCK) {
 677                 cFYI(1, ("F_RDLCK"));
 678                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 679                 numLock = 1;
 680         } else if (pfLock->fl_type == F_EXLCK) {
 681                 cFYI(1, ("F_EXLCK"));
 682                 numLock = 1;
 683         } else if (pfLock->fl_type == F_SHLCK) {
 684                 cFYI(1, ("F_SHLCK"));
 685                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 686                 numLock = 1;
 687         } else
 688                 cFYI(1, ("Unknown type of lock"));
 689
 690         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 691         pTcon = cifs_sb->tcon;
 692
 693         if (file->private_data == NULL) {
 694                 FreeXid(xid);
 695                 return -EBADF;
 696         }
 697         netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
 698
 699         posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
 700                         (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
 701
 702         /* BB add code here to normalize offset and length to
 703         account for negative length which we can not accept over the
 704         wire */
 705         if (IS_GETLK(cmd)) {
 706                 if (posix_locking) {
 707                         int posix_lock_type;
 708                         if (lockType & LOCKING_ANDX_SHARED_LOCK)
 709                                 posix_lock_type = CIFS_RDLCK;
 710                         else
 711                                 posix_lock_type = CIFS_WRLCK;
 712                         rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
 713                                         length, pfLock,
 714                                         posix_lock_type, wait_flag);
 715                         FreeXid(xid);
 716                         return rc;
 717                 }
 718
 719                 /* BB we could chain these into one lock request BB */
 720                 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
 721                                  0, 1, lockType, 0 /* wait flag */ );
 722                 if (rc == 0) {
 723                         rc = CIFSSMBLock(xid, pTcon, netfid, length,
 724                                          pfLock->fl_start, 1 /* numUnlock */ ,
 725                                          0 /* numLock */ , lockType,
 726                                          0 /* wait flag */ );
 727                         pfLock->fl_type = F_UNLCK;
 728                         if (rc != 0)
 729                                 cERROR(1, ("Error unlocking previously locked "
 730                                            "range %d during test of lock", rc));
 731                         rc = 0;
 732
 733                 } else {
 734                         /* if rc == ERR_SHARING_VIOLATION ? */
 735                         rc = 0; /* do not change lock type to unlock
 736                                    since range in use */
 737                 }
 738
 739                 FreeXid(xid);
 740                 return rc;
 741         }
 742
 743         if (!numLock && !numUnlock) {
 744                 /* if no lock or unlock then nothing
 745                 to do since we do not know what it is */
 746                 FreeXid(xid);
 747                 return -EOPNOTSUPP;
 748         }
 749
 750         if (posix_locking) {
 751                 int posix_lock_type;
 752                 if (lockType & LOCKING_ANDX_SHARED_LOCK)
 753                         posix_lock_type = CIFS_RDLCK;
 754                 else
 755                         posix_lock_type = CIFS_WRLCK;
 756
 757                 if (numUnlock == 1)
 758                         posix_lock_type = CIFS_UNLCK;
 759
 760                 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
 761                                       length, pfLock,
 762                                       posix_lock_type, wait_flag);
 763         } else {
 764                 struct cifsFileInfo *fid =
 765                         (struct cifsFileInfo *)file->private_data;
 766
 767                 if (numLock) {
 768                         rc = CIFSSMBLock(xid, pTcon, netfid, length,
 769                                         pfLock->fl_start,
 770                                         0, numLock, lockType, wait_flag);
 771
 772                         if (rc == 0) {
 773                                 /* For Windows locks we must store them. */
 774                                 rc = store_file_lock(fid, length,
 775                                                 pfLock->fl_start, lockType);
 776                         }
 777                 } else if (numUnlock) {
 778                         /* For each stored lock that this unlock overlaps
 779                            completely, unlock it. */
 780                         int stored_rc = 0;
 781                         struct cifsLockInfo *li, *tmp;
 782
 783                         rc = 0;
 784                         mutex_lock(&fid->lock_mutex);
 785                         list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
 786                                 if (pfLock->fl_start <= li->offset &&
 787                                                 (pfLock->fl_start + length) >=
 788                                                 (li->offset + li->length)) {
 789                                         stored_rc = CIFSSMBLock(xid, pTcon,
 790                                                         netfid,
 791                                                         li->length, li->offset,
 792                                                         1, 0, li->type, FALSE);
 793                                         if (stored_rc)
 794                                                 rc = stored_rc;
 795
 796                                         list_del(&li->llist);
 797                                         kfree(li);
 798                                 }
 799                         }
 800                         mutex_unlock(&fid->lock_mutex);
 801                 }
 802         }
 803
 804         if (pfLock->fl_flags & FL_POSIX)
 805                 posix_lock_file_wait(file, pfLock);
 806         FreeXid(xid);
 807         return rc;
 808 }
 809
 810 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
 811         size_t write_size, loff_t *poffset)
 812 {
 813         int rc = 0;
 814         unsigned int bytes_written = 0;
 815         unsigned int total_written;
 816         struct cifs_sb_info *cifs_sb;
 817         struct cifsTconInfo *pTcon;
 818         int xid, long_op;
 819         struct cifsFileInfo *open_file;
 820
 821         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 822
 823         pTcon = cifs_sb->tcon;
 824
 825         /* cFYI(1,
 826            (" write %d bytes to offset %lld of %s", write_size,
 827            *poffset, file->f_path.dentry->d_name.name)); */
 828
 829         if (file->private_data == NULL)
 830                 return -EBADF;
 831         open_file = (struct cifsFileInfo *) file->private_data;
 832
 833         xid = GetXid();
 834
 835         if (*poffset > file->f_path.dentry->d_inode->i_size)
 836                 long_op = 2; /* writes past end of file can take a long time */
 837         else
 838                 long_op = 1;
 839
 840         for (total_written = 0; write_size > total_written;
 841              total_written += bytes_written) {
 842                 rc = -EAGAIN;
 843                 while (rc == -EAGAIN) {
 844                         if (file->private_data == NULL) {
 845                                 /* file has been closed on us */
 846                                 FreeXid(xid);
 847                         /* if we have gotten here we have written some data
 848                            and blocked, and the file has been freed on us while
 849                            we blocked so return what we managed to write */
 850                                 return total_written;
 851                         }
 852                         if (open_file->closePend) {
 853                                 FreeXid(xid);
 854                                 if (total_written)
 855                                         return total_written;
 856                                 else
 857                                         return -EBADF;
 858                         }
 859                         if (open_file->invalidHandle) {
 860                                 /* we could deadlock if we called
 861                                    filemap_fdatawait from here so tell
 862                                    reopen_file not to flush data to server
 863                                    now */
 864                                 rc = cifs_reopen_file(file, FALSE);
 865                                 if (rc != 0)
 866                                         break;
 867                         }
 868
 869                         rc = CIFSSMBWrite(xid, pTcon,
 870                                 open_file->netfid,
 871                                 min_t(const int, cifs_sb->wsize,
 872                                       write_size - total_written),
 873                                 *poffset, &bytes_written,
 874                                 NULL, write_data + total_written, long_op);
 875                 }
 876                 if (rc || (bytes_written == 0)) {
 877                         if (total_written)
 878                                 break;
 879                         else {
 880                                 FreeXid(xid);
 881                                 return rc;
 882                         }
 883                 } else
 884                         *poffset += bytes_written;
 885                 long_op = FALSE; /* subsequent writes fast -
 886                                     15 seconds is plenty */
 887         }
 888
 889         cifs_stats_bytes_written(pTcon, total_written);
 890
 891         /* since the write may have blocked check these pointers again */
 892         if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
 893                 struct inode *inode = file->f_path.dentry->d_inode;
 894 /* Do not update local mtime - server will set its actual value on write
 895  *              inode->i_ctime = inode->i_mtime =
 896  *                      current_fs_time(inode->i_sb);*/
 897                 if (total_written > 0) {
 898                         spin_lock(&inode->i_lock);
 899                         if (*poffset > file->f_path.dentry->d_inode->i_size)
 900                                 i_size_write(file->f_path.dentry->d_inode,
 901                                         *poffset);
 902                         spin_unlock(&inode->i_lock);
 903                 }
 904                 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
 905         }
 906         FreeXid(xid);
 907         return total_written;
 908 }
 909
 910 static ssize_t cifs_write(struct file *file, const char *write_data,
 911         size_t write_size, loff_t *poffset)
 912 {
 913         int rc = 0;
 914         unsigned int bytes_written = 0;
 915         unsigned int total_written;
 916         struct cifs_sb_info *cifs_sb;
 917         struct cifsTconInfo *pTcon;
 918         int xid, long_op;
 919         struct cifsFileInfo *open_file;
 920
 921         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 922
 923         pTcon = cifs_sb->tcon;
 924
 925         cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
 926            *poffset, file->f_path.dentry->d_name.name));
 927
 928         if (file->private_data == NULL)
 929                 return -EBADF;
 930         open_file = (struct cifsFileInfo *)file->private_data;
 931
 932         xid = GetXid();
 933
 934         if (*poffset > file->f_path.dentry->d_inode->i_size)
 935                 long_op = 2; /* writes past end of file can take a long time */
 936         else
 937                 long_op = 1;
 938
 939         for (total_written = 0; write_size > total_written;
 940              total_written += bytes_written) {
 941                 rc = -EAGAIN;
 942                 while (rc == -EAGAIN) {
 943                         if (file->private_data == NULL) {
 944                                 /* file has been closed on us */
 945                                 FreeXid(xid);
 946                         /* if we have gotten here we have written some data
 947                            and blocked, and the file has been freed on us
 948                            while we blocked so return what we managed to
 949                            write */
 950                                 return total_written;
 951                         }
 952                         if (open_file->closePend) {
 953                                 FreeXid(xid);
 954                                 if (total_written)
 955                                         return total_written;
 956                                 else
 957                                         return -EBADF;
 958                         }
 959                         if (open_file->invalidHandle) {
 960                                 /* we could deadlock if we called
 961                                    filemap_fdatawait from here so tell
 962                                    reopen_file not to flush data to
 963                                    server now */
 964                                 rc = cifs_reopen_file(file, FALSE);
 965                                 if (rc != 0)
 966                                         break;
 967                         }
 968                         if (experimEnabled || (pTcon->ses->server &&
 969                                 ((pTcon->ses->server->secMode &
 970                                 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 971                                 == 0))) {
 972                                 struct kvec iov[2];
 973                                 unsigned int len;
 974
 975                                 len = min((size_t)cifs_sb->wsize,
 976                                           write_size - total_written);
 977                                 /* iov[0] is reserved for smb header */
 978                                 iov[1].iov_base = (char *)write_data +
 979                                                   total_written;
 980                                 iov[1].iov_len = len;
 981                                 rc = CIFSSMBWrite2(xid, pTcon,
 982                                                 open_file->netfid, len,
 983                                                 *poffset, &bytes_written,
 984                                                 iov, 1, long_op);
 985                         } else
 986                                 rc = CIFSSMBWrite(xid, pTcon,
 987                                          open_file->netfid,
 988                                          min_t(const int, cifs_sb->wsize,
 989                                                write_size - total_written),
 990                                          *poffset, &bytes_written,
 991                                          write_data + total_written,
 992                                          NULL, long_op);
 993                 }
 994                 if (rc || (bytes_written == 0)) {
 995                         if (total_written)
 996                                 break;
 997                         else {
 998                                 FreeXid(xid);
 999                                 return rc;
1000                         }
1001                 } else
1002                         *poffset += bytes_written;
1003                 long_op = FALSE; /* subsequent writes fast -
1004                                     15 seconds is plenty */
1005         }
1006
1007         cifs_stats_bytes_written(pTcon, total_written);
1008
1009         /* since the write may have blocked check these pointers again */
1010         if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1011 /*BB We could make this contingent on superblock ATIME flag too */
1012 /*              file->f_path.dentry->d_inode->i_ctime =
1013                 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1014                 if (total_written > 0) {
1015                         spin_lock(&file->f_path.dentry->d_inode->i_lock);
1016                         if (*poffset > file->f_path.dentry->d_inode->i_size)
1017                                 i_size_write(file->f_path.dentry->d_inode,
1018                                              *poffset);
1019                         spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1020                 }
1021                 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1022         }
1023         FreeXid(xid);
1024         return total_written;
1025 }
1026
1027 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1028 {
1029         struct cifsFileInfo *open_file;
1030         int rc;
1031
1032         /* Having a null inode here (because mapping->host was set to zero by
1033         the VFS or MM) should not happen but we had reports of on oops (due to
1034         it being zero) during stress testcases so we need to check for it */
1035
1036         if (cifs_inode == NULL) {
1037                 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1038                 dump_stack();
1039                 return NULL;
1040         }
1041
1042         read_lock(&GlobalSMBSeslock);
1043         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1044                 if (open_file->closePend)
1045                         continue;
1046                 if (open_file->pfile &&
1047                     ((open_file->pfile->f_flags & O_RDWR) ||
1048                      (open_file->pfile->f_flags & O_WRONLY))) {
1049                         atomic_inc(&open_file->wrtPending);
1050                         read_unlock(&GlobalSMBSeslock);
1051                         if (open_file->invalidHandle) {
1052                                 rc = cifs_reopen_file(open_file->pfile, FALSE);
1053                                 /* if it fails, try another handle - might be */
1054                                 /* dangerous to hold up writepages with retry */
1055                                 if (rc) {
1056                                         cFYI(1, ("wp failed on reopen file"));
1057                                         read_lock(&GlobalSMBSeslock);
1058                                         /* can not use this handle, no write
1059                                         pending on this one after all */
1060                                         atomic_dec(&open_file->wrtPending);
1061                                         continue;
1062                                 }
1063                         }
1064                         if (open_file->closePend) {
1065                                 read_lock(&GlobalSMBSeslock);
1066                                 atomic_dec(&open_file->wrtPending);
1067                                 continue;
1068                         }
1069                         return open_file;
1070                 }
1071         }
1072         read_unlock(&GlobalSMBSeslock);
1073         return NULL;
1074 }
1075
1076 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1077 {
1078         struct address_space *mapping = page->mapping;
1079         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1080         char *write_data;
1081         int rc = -EFAULT;
1082         int bytes_written = 0;
1083         struct cifs_sb_info *cifs_sb;
1084         struct cifsTconInfo *pTcon;
1085         struct inode *inode;
1086         struct cifsFileInfo *open_file;
1087
1088         if (!mapping || !mapping->host)
1089                 return -EFAULT;
1090
1091         inode = page->mapping->host;
1092         cifs_sb = CIFS_SB(inode->i_sb);
1093         pTcon = cifs_sb->tcon;
1094
1095         offset += (loff_t)from;
1096         write_data = kmap(page);
1097         write_data += from;
1098
1099         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1100                 kunmap(page);
1101                 return -EIO;
1102         }
1103
1104         /* racing with truncate? */
1105         if (offset > mapping->host->i_size) {
1106                 kunmap(page);
1107                 return 0; /* don't care */
1108         }
1109
1110         /* check to make sure that we are not extending the file */
1111         if (mapping->host->i_size - offset < (loff_t)to)
1112                 to = (unsigned)(mapping->host->i_size - offset);
1113
1114         open_file = find_writable_file(CIFS_I(mapping->host));
1115         if (open_file) {
1116                 bytes_written = cifs_write(open_file->pfile, write_data,
1117                                            to-from, &offset);
1118                 atomic_dec(&open_file->wrtPending);
1119                 /* Does mm or vfs already set times? */
1120                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1121                 if ((bytes_written > 0) && (offset)) {
1122                         rc = 0;
1123                 } else if (bytes_written < 0) {
1124                         if (rc != -EBADF)
1125                                 rc = bytes_written;
1126                 }
1127         } else {
1128                 cFYI(1, ("No writeable filehandles for inode"));
1129                 rc = -EIO;
1130         }
1131
1132         kunmap(page);
1133         return rc;
1134 }
1135
1136 static int cifs_writepages(struct address_space *mapping,
1137                            struct writeback_control *wbc)
1138 {
1139         struct backing_dev_info *bdi = mapping->backing_dev_info;
1140         unsigned int bytes_to_write;
1141         unsigned int bytes_written;
1142         struct cifs_sb_info *cifs_sb;
1143         int done = 0;
1144         pgoff_t end;
1145         pgoff_t index;
1146         int range_whole = 0;
1147         struct kvec *iov;
1148         int len;
1149         int n_iov = 0;
1150         pgoff_t next;
1151         int nr_pages;
1152         __u64 offset = 0;
1153         struct cifsFileInfo *open_file;
1154         struct page *page;
1155         struct pagevec pvec;
1156         int rc = 0;
1157         int scanned = 0;
1158         int xid;
1159
1160         cifs_sb = CIFS_SB(mapping->host->i_sb);
1161
1162         /*
1163          * If wsize is smaller that the page cache size, default to writing
1164          * one page at a time via cifs_writepage
1165          */
1166         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1167                 return generic_writepages(mapping, wbc);
1168
1169         if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1170                 if (cifs_sb->tcon->ses->server->secMode &
1171                                 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1172                         if (!experimEnabled)
1173                                 return generic_writepages(mapping, wbc);
1174
1175         iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1176         if (iov == NULL)
1177                 return generic_writepages(mapping, wbc);
1178
1179
1180         /*
1181          * BB: Is this meaningful for a non-block-device file system?
1182          * If it is, we should test it again after we do I/O
1183          */
1184         if (wbc->nonblocking && bdi_write_congested(bdi)) {
1185                 wbc->encountered_congestion = 1;
1186                 kfree(iov);
1187                 return 0;
1188         }
1189
1190         xid = GetXid();
1191
1192         pagevec_init(&pvec, 0);
1193         if (wbc->range_cyclic) {
1194                 index = mapping->writeback_index; /* Start from prev offset */
1195                 end = -1;
1196         } else {
1197                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1198                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1199                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1200                         range_whole = 1;
1201                 scanned = 1;
1202         }
1203 retry:
1204         while (!done && (index <= end) &&
1205                (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1206                         PAGECACHE_TAG_DIRTY,
1207                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1208                 int first;
1209                 unsigned int i;
1210
1211                 first = -1;
1212                 next = 0;
1213                 n_iov = 0;
1214                 bytes_to_write = 0;
1215
1216                 for (i = 0; i < nr_pages; i++) {
1217                         page = pvec.pages[i];
1218                         /*
1219                          * At this point we hold neither mapping->tree_lock nor
1220                          * lock on the page itself: the page may be truncated or
1221                          * invalidated (changing page->mapping to NULL), or even
1222                          * swizzled back from swapper_space to tmpfs file
1223                          * mapping
1224                          */
1225
1226                         if (first < 0)
1227                                 lock_page(page);
1228                         else if (TestSetPageLocked(page))
1229                                 break;
1230
1231                         if (unlikely(page->mapping != mapping)) {
1232                                 unlock_page(page);
1233                                 break;
1234                         }
1235
1236                         if (!wbc->range_cyclic && page->index > end) {
1237                                 done = 1;
1238                                 unlock_page(page);
1239                                 break;
1240                         }
1241
1242                         if (next && (page->index != next)) {
1243                                 /* Not next consecutive page */
1244                                 unlock_page(page);
1245                                 break;
1246                         }
1247
1248                         if (wbc->sync_mode != WB_SYNC_NONE)
1249                                 wait_on_page_writeback(page);
1250
1251                         if (PageWriteback(page) ||
1252                                         !clear_page_dirty_for_io(page)) {
1253                                 unlock_page(page);
1254                                 break;
1255                         }
1256
1257                         /*
1258                          * This actually clears the dirty bit in the radix tree.
1259                          * See cifs_writepage() for more commentary.
1260                          */
1261                         set_page_writeback(page);
1262
1263                         if (page_offset(page) >= mapping->host->i_size) {
1264                                 done = 1;
1265                                 unlock_page(page);
1266                                 end_page_writeback(page);
1267                                 break;
1268                         }
1269
1270                         /*
1271                          * BB can we get rid of this?  pages are held by pvec
1272                          */
1273                         page_cache_get(page);
1274
1275                         len = min(mapping->host->i_size - page_offset(page),
1276                                   (loff_t)PAGE_CACHE_SIZE);
1277
1278                         /* reserve iov[0] for the smb header */
1279                         n_iov++;
1280                         iov[n_iov].iov_base = kmap(page);
1281                         iov[n_iov].iov_len = len;
1282                         bytes_to_write += len;
1283
1284                         if (first < 0) {
1285                                 first = i;
1286                                 offset = page_offset(page);
1287                         }
1288                         next = page->index + 1;
1289                         if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1290                                 break;
1291                 }
1292                 if (n_iov) {
1293                         /* Search for a writable handle every time we call
1294                          * CIFSSMBWrite2.  We can't rely on the last handle
1295                          * we used to still be valid
1296                          */
1297                         open_file = find_writable_file(CIFS_I(mapping->host));
1298                         if (!open_file) {
1299                                 cERROR(1, ("No writable handles for inode"));
1300                                 rc = -EBADF;
1301                         } else {
1302                                 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1303                                                    open_file->netfid,
1304                                                    bytes_to_write, offset,
1305                                                    &bytes_written, iov, n_iov,
1306                                                    1);
1307                                 atomic_dec(&open_file->wrtPending);
1308                                 if (rc || bytes_written < bytes_to_write) {
1309                                         cERROR(1, ("Write2 ret %d, wrote %d",
1310                                                   rc, bytes_written));
1311                                         /* BB what if continued retry is
1312                                            requested via mount flags? */
1313                                         set_bit(AS_EIO, &mapping->flags);
1314                                 } else {
1315                                         cifs_stats_bytes_written(cifs_sb->tcon,
1316                                                                  bytes_written);
1317                                 }
1318                         }
1319                         for (i = 0; i < n_iov; i++) {
1320                                 page = pvec.pages[first + i];
1321                                 /* Should we also set page error on
1322                                 success rc but too little data written? */
1323                                 /* BB investigate retry logic on temporary
1324                                 server crash cases and how recovery works
1325                                 when page marked as error */
1326                                 if (rc)
1327                                         SetPageError(page);
1328                                 kunmap(page);
1329                                 unlock_page(page);
1330                                 end_page_writeback(page);
1331                                 page_cache_release(page);
1332                         }
1333                         if ((wbc->nr_to_write -= n_iov) <= 0)
1334                                 done = 1;
1335                         index = next;
1336                 }
1337                 pagevec_release(&pvec);
1338         }
1339         if (!scanned && !done) {
1340                 /*
1341                  * We hit the last page and there is more work to be done: wrap
1342                  * back to the start of the file
1343                  */
1344                 scanned = 1;
1345                 index = 0;
1346                 goto retry;
1347         }
1348         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1349                 mapping->writeback_index = index;
1350
1351         FreeXid(xid);
1352         kfree(iov);
1353         return rc;
1354 }
1355
1356 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1357 {
1358         int rc = -EFAULT;
1359         int xid;
1360
1361         xid = GetXid();
1362 /* BB add check for wbc flags */
1363         page_cache_get(page);
1364         if (!PageUptodate(page)) {
1365                 cFYI(1, ("ppw - page not up to date"));
1366         }
1367
1368         /*
1369          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1370          *
1371          * A writepage() implementation always needs to do either this,
1372          * or re-dirty the page with "redirty_page_for_writepage()" in
1373          * the case of a failure.
1374          *
1375          * Just unlocking the page will cause the radix tree tag-bits
1376          * to fail to update with the state of the page correctly.
1377          */
1378         set_page_writeback(page);
1379         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1380         SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1381         unlock_page(page);
1382         end_page_writeback(page);
1383         page_cache_release(page);
1384         FreeXid(xid);
1385         return rc;
1386 }
1387
1388 static int cifs_commit_write(struct file *file, struct page *page,
1389         unsigned offset, unsigned to)
1390 {
1391         int xid;
1392         int rc = 0;
1393         struct inode *inode = page->mapping->host;
1394         loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1395         char *page_data;
1396
1397         xid = GetXid();
1398         cFYI(1, ("commit write for page %p up to position %lld for %d",
1399                  page, position, to));
1400         spin_lock(&inode->i_lock);
1401         if (position > inode->i_size) {
1402                 i_size_write(inode, position);
1403         }
1404         spin_unlock(&inode->i_lock);
1405         if (!PageUptodate(page)) {
1406                 position =  ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1407                 /* can not rely on (or let) writepage write this data */
1408                 if (to < offset) {
1409                         cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1410                                 offset, to));
1411                         FreeXid(xid);
1412                         return rc;
1413                 }
1414                 /* this is probably better than directly calling
1415                    partialpage_write since in this function the file handle is
1416                    known which we might as well leverage */
1417                 /* BB check if anything else missing out of ppw
1418                    such as updating last write time */
1419                 page_data = kmap(page);
1420                 rc = cifs_write(file, page_data + offset, to-offset,
1421                                 &position);
1422                 if (rc > 0)
1423                         rc = 0;
1424                 /* else if (rc < 0) should we set writebehind rc? */
1425                 kunmap(page);
1426         } else {
1427                 set_page_dirty(page);
1428         }
1429
1430         FreeXid(xid);
1431         return rc;
1432 }
1433
1434 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1435 {
1436         int xid;
1437         int rc = 0;
1438         struct inode *inode = file->f_path.dentry->d_inode;
1439
1440         xid = GetXid();
1441
1442         cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1443                 dentry->d_name.name, datasync));
1444
1445         rc = filemap_fdatawrite(inode->i_mapping);
1446         if (rc == 0)
1447                 CIFS_I(inode)->write_behind_rc = 0;
1448         FreeXid(xid);
1449         return rc;
1450 }
1451
1452 /* static void cifs_sync_page(struct page *page)
1453 {
1454         struct address_space *mapping;
1455         struct inode *inode;
1456         unsigned long index = page->index;
1457         unsigned int rpages = 0;
1458         int rc = 0;
1459
1460         cFYI(1, ("sync page %p",page));
1461         mapping = page->mapping;
1462         if (!mapping)
1463                 return 0;
1464         inode = mapping->host;
1465         if (!inode)
1466                 return; */
1467
1468 /*      fill in rpages then
1469         result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1470
1471 /*      cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1472
1473 #if 0
1474         if (rc < 0)
1475                 return rc;
1476         return 0;
1477 #endif
1478 } */
1479
1480 /*
1481  * As file closes, flush all cached write data for this inode checking
1482  * for write behind errors.
1483  */
1484 int cifs_flush(struct file *file, fl_owner_t id)
1485 {
1486         struct inode *inode = file->f_path.dentry->d_inode;
1487         int rc = 0;
1488
1489         /* Rather than do the steps manually:
1490            lock the inode for writing
1491            loop through pages looking for write behind data (dirty pages)
1492            coalesce into contiguous 16K (or smaller) chunks to write to server
1493            send to server (prefer in parallel)
1494            deal with writebehind errors
1495            unlock inode for writing
1496            filemapfdatawrite appears easier for the time being */
1497
1498         rc = filemap_fdatawrite(inode->i_mapping);
1499         if (!rc) /* reset wb rc if we were able to write out dirty pages */
1500                 CIFS_I(inode)->write_behind_rc = 0;
1501
1502         cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
1503
1504         return rc;
1505 }
1506
1507 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1508         size_t read_size, loff_t *poffset)
1509 {
1510         int rc = -EACCES;
1511         unsigned int bytes_read = 0;
1512         unsigned int total_read = 0;
1513         unsigned int current_read_size;
1514         struct cifs_sb_info *cifs_sb;
1515         struct cifsTconInfo *pTcon;
1516         int xid;
1517         struct cifsFileInfo *open_file;
1518         char *smb_read_data;
1519         char __user *current_offset;
1520         struct smb_com_read_rsp *pSMBr;
1521
1522         xid = GetXid();
1523         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1524         pTcon = cifs_sb->tcon;
1525
1526         if (file->private_data == NULL) {
1527                 FreeXid(xid);
1528                 return -EBADF;
1529         }
1530         open_file = (struct cifsFileInfo *)file->private_data;
1531
1532         if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1533                 cFYI(1, ("attempting read on write only file instance"));
1534         }
1535         for (total_read = 0, current_offset = read_data;
1536              read_size > total_read;
1537              total_read += bytes_read, current_offset += bytes_read) {
1538                 current_read_size = min_t(const int, read_size - total_read,
1539                                           cifs_sb->rsize);
1540                 rc = -EAGAIN;
1541                 smb_read_data = NULL;
1542                 while (rc == -EAGAIN) {
1543                         int buf_type = CIFS_NO_BUFFER;
1544                         if ((open_file->invalidHandle) &&
1545                             (!open_file->closePend)) {
1546                                 rc = cifs_reopen_file(file, TRUE);
1547                                 if (rc != 0)
1548                                         break;
1549                         }
1550                         rc = CIFSSMBRead(xid, pTcon,
1551                                          open_file->netfid,
1552                                          current_read_size, *poffset,
1553                                          &bytes_read, &smb_read_data,
1554                                          &buf_type);
1555                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1556                         if (smb_read_data) {
1557                                 if (copy_to_user(current_offset,
1558                                                 smb_read_data +
1559                                                 4 /* RFC1001 length field */ +
1560                                                 le16_to_cpu(pSMBr->DataOffset),
1561                                                 bytes_read)) {
1562                                         rc = -EFAULT;
1563                                 }
1564
1565                                 if (buf_type == CIFS_SMALL_BUFFER)
1566                                         cifs_small_buf_release(smb_read_data);
1567                                 else if (buf_type == CIFS_LARGE_BUFFER)
1568                                         cifs_buf_release(smb_read_data);
1569                                 smb_read_data = NULL;
1570                         }
1571                 }
1572                 if (rc || (bytes_read == 0)) {
1573                         if (total_read) {
1574                                 break;
1575                         } else {
1576                                 FreeXid(xid);
1577                                 return rc;
1578                         }
1579                 } else {
1580                         cifs_stats_bytes_read(pTcon, bytes_read);
1581                         *poffset += bytes_read;
1582                 }
1583         }
1584         FreeXid(xid);
1585         return total_read;
1586 }
1587
1588
1589 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1590         loff_t *poffset)
1591 {
1592         int rc = -EACCES;
1593         unsigned int bytes_read = 0;
1594         unsigned int total_read;
1595         unsigned int current_read_size;
1596         struct cifs_sb_info *cifs_sb;
1597         struct cifsTconInfo *pTcon;
1598         int xid;
1599         char *current_offset;
1600         struct cifsFileInfo *open_file;
1601         int buf_type = CIFS_NO_BUFFER;
1602
1603         xid = GetXid();
1604         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1605         pTcon = cifs_sb->tcon;
1606
1607         if (file->private_data == NULL) {
1608                 FreeXid(xid);
1609                 return -EBADF;
1610         }
1611         open_file = (struct cifsFileInfo *)file->private_data;
1612
1613         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1614                 cFYI(1, ("attempting read on write only file instance"));
1615
1616         for (total_read = 0, current_offset = read_data;
1617              read_size > total_read;
1618              total_read += bytes_read, current_offset += bytes_read) {
1619                 current_read_size = min_t(const int, read_size - total_read,
1620                                           cifs_sb->rsize);
1621                 /* For windows me and 9x we do not want to request more
1622                 than it negotiated since it will refuse the read then */
1623                 if ((pTcon->ses) &&
1624                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1625                         current_read_size = min_t(const int, current_read_size,
1626                                         pTcon->ses->server->maxBuf - 128);
1627                 }
1628                 rc = -EAGAIN;
1629                 while (rc == -EAGAIN) {
1630                         if ((open_file->invalidHandle) &&
1631                             (!open_file->closePend)) {
1632                                 rc = cifs_reopen_file(file, TRUE);
1633                                 if (rc != 0)
1634                                         break;
1635                         }
1636                         rc = CIFSSMBRead(xid, pTcon,
1637                                          open_file->netfid,
1638                                          current_read_size, *poffset,
1639                                          &bytes_read, &current_offset,
1640                                          &buf_type);
1641                 }
1642                 if (rc || (bytes_read == 0)) {
1643                         if (total_read) {
1644                                 break;
1645                         } else {
1646                                 FreeXid(xid);
1647                                 return rc;
1648                         }
1649                 } else {
1650                         cifs_stats_bytes_read(pTcon, total_read);
1651                         *poffset += bytes_read;
1652                 }
1653         }
1654         FreeXid(xid);
1655         return total_read;
1656 }
1657
1658 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1659 {
1660         struct dentry *dentry = file->f_path.dentry;
1661         int rc, xid;
1662
1663         xid = GetXid();
1664         rc = cifs_revalidate(dentry);
1665         if (rc) {
1666                 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1667                 FreeXid(xid);
1668                 return rc;
1669         }
1670         rc = generic_file_mmap(file, vma);
1671         FreeXid(xid);
1672         return rc;
1673 }
1674
1675
1676 static void cifs_copy_cache_pages(struct address_space *mapping,
1677         struct list_head *pages, int bytes_read, char *data,
1678         struct pagevec *plru_pvec)
1679 {
1680         struct page *page;
1681         char *target;
1682
1683         while (bytes_read > 0) {
1684                 if (list_empty(pages))
1685                         break;
1686
1687                 page = list_entry(pages->prev, struct page, lru);
1688                 list_del(&page->lru);
1689
1690                 if (add_to_page_cache(page, mapping, page->index,
1691                                       GFP_KERNEL)) {
1692                         page_cache_release(page);
1693                         cFYI(1, ("Add page cache failed"));
1694                         data += PAGE_CACHE_SIZE;
1695                         bytes_read -= PAGE_CACHE_SIZE;
1696                         continue;
1697                 }
1698
1699                 target = kmap_atomic(page, KM_USER0);
1700
1701                 if (PAGE_CACHE_SIZE > bytes_read) {
1702                         memcpy(target, data, bytes_read);
1703                         /* zero the tail end of this partial page */
1704                         memset(target + bytes_read, 0,
1705                                PAGE_CACHE_SIZE - bytes_read);
1706                         bytes_read = 0;
1707                 } else {
1708                         memcpy(target, data, PAGE_CACHE_SIZE);
1709                         bytes_read -= PAGE_CACHE_SIZE;
1710                 }
1711                 kunmap_atomic(target, KM_USER0);
1712
1713                 flush_dcache_page(page);
1714                 SetPageUptodate(page);
1715                 unlock_page(page);
1716                 if (!pagevec_add(plru_pvec, page))
1717                         __pagevec_lru_add(plru_pvec);
1718                 data += PAGE_CACHE_SIZE;
1719         }
1720         return;
1721 }
1722
1723 static int cifs_readpages(struct file *file, struct address_space *mapping,
1724         struct list_head *page_list, unsigned num_pages)
1725 {
1726         int rc = -EACCES;
1727         int xid;
1728         loff_t offset;
1729         struct page *page;
1730         struct cifs_sb_info *cifs_sb;
1731         struct cifsTconInfo *pTcon;
1732         int bytes_read = 0;
1733         unsigned int read_size, i;
1734         char *smb_read_data = NULL;
1735         struct smb_com_read_rsp *pSMBr;
1736         struct pagevec lru_pvec;
1737         struct cifsFileInfo *open_file;
1738         int buf_type = CIFS_NO_BUFFER;
1739
1740         xid = GetXid();
1741         if (file->private_data == NULL) {
1742                 FreeXid(xid);
1743                 return -EBADF;
1744         }
1745         open_file = (struct cifsFileInfo *)file->private_data;
1746         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1747         pTcon = cifs_sb->tcon;
1748
1749         pagevec_init(&lru_pvec, 0);
1750 #ifdef CONFIG_CIFS_DEBUG2
1751                 cFYI(1, ("rpages: num pages %d", num_pages));
1752 #endif
1753         for (i = 0; i < num_pages; ) {
1754                 unsigned contig_pages;
1755                 struct page *tmp_page;
1756                 unsigned long expected_index;
1757
1758                 if (list_empty(page_list))
1759                         break;
1760
1761                 page = list_entry(page_list->prev, struct page, lru);
1762                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1763
1764                 /* count adjacent pages that we will read into */
1765                 contig_pages = 0;
1766                 expected_index =
1767                         list_entry(page_list->prev, struct page, lru)->index;
1768                 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1769                         if (tmp_page->index == expected_index) {
1770                                 contig_pages++;
1771                                 expected_index++;
1772                         } else
1773                                 break;
1774                 }
1775                 if (contig_pages + i >  num_pages)
1776                         contig_pages = num_pages - i;
1777
1778                 /* for reads over a certain size could initiate async
1779                    read ahead */
1780
1781                 read_size = contig_pages * PAGE_CACHE_SIZE;
1782                 /* Read size needs to be in multiples of one page */
1783                 read_size = min_t(const unsigned int, read_size,
1784                                   cifs_sb->rsize & PAGE_CACHE_MASK);
1785 #ifdef CONFIG_CIFS_DEBUG2
1786                 cFYI(1, ("rpages: read size 0x%x  contiguous pages %d",
1787                                 read_size, contig_pages));
1788 #endif
1789                 rc = -EAGAIN;
1790                 while (rc == -EAGAIN) {
1791                         if ((open_file->invalidHandle) &&
1792                             (!open_file->closePend)) {
1793                                 rc = cifs_reopen_file(file, TRUE);
1794                                 if (rc != 0)
1795                                         break;
1796                         }
1797
1798                         rc = CIFSSMBRead(xid, pTcon,
1799                                          open_file->netfid,
1800                                          read_size, offset,
1801                                          &bytes_read, &smb_read_data,
1802                                          &buf_type);
1803                         /* BB more RC checks ? */
1804                         if (rc == -EAGAIN) {
1805                                 if (smb_read_data) {
1806                                         if (buf_type == CIFS_SMALL_BUFFER)
1807                                                 cifs_small_buf_release(smb_read_data);
1808                                         else if (buf_type == CIFS_LARGE_BUFFER)
1809                                                 cifs_buf_release(smb_read_data);
1810                                         smb_read_data = NULL;
1811                                 }
1812                         }
1813                 }
1814                 if ((rc < 0) || (smb_read_data == NULL)) {
1815                         cFYI(1, ("Read error in readpages: %d", rc));
1816                         break;
1817                 } else if (bytes_read > 0) {
1818                         task_io_account_read(bytes_read);
1819                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1820                         cifs_copy_cache_pages(mapping, page_list, bytes_read,
1821                                 smb_read_data + 4 /* RFC1001 hdr */ +
1822                                 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1823
1824                         i +=  bytes_read >> PAGE_CACHE_SHIFT;
1825                         cifs_stats_bytes_read(pTcon, bytes_read);
1826                         if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1827                                 i++; /* account for partial page */
1828
1829                                 /* server copy of file can have smaller size
1830                                    than client */
1831                                 /* BB do we need to verify this common case ?
1832                                    this case is ok - if we are at server EOF
1833                                    we will hit it on next read */
1834
1835                                 /* break; */
1836                         }
1837                 } else {
1838                         cFYI(1, ("No bytes read (%d) at offset %lld . "
1839                                  "Cleaning remaining pages from readahead list",
1840                                  bytes_read, offset));
1841                         /* BB turn off caching and do new lookup on
1842                            file size at server? */
1843                         break;
1844                 }
1845                 if (smb_read_data) {
1846                         if (buf_type == CIFS_SMALL_BUFFER)
1847                                 cifs_small_buf_release(smb_read_data);
1848                         else if (buf_type == CIFS_LARGE_BUFFER)
1849                                 cifs_buf_release(smb_read_data);
1850                         smb_read_data = NULL;
1851                 }
1852                 bytes_read = 0;
1853         }
1854
1855         pagevec_lru_add(&lru_pvec);
1856
1857 /* need to free smb_read_data buf before exit */
1858         if (smb_read_data) {
1859                 if (buf_type == CIFS_SMALL_BUFFER)
1860                         cifs_small_buf_release(smb_read_data);
1861                 else if (buf_type == CIFS_LARGE_BUFFER)
1862                         cifs_buf_release(smb_read_data);
1863                 smb_read_data = NULL;
1864         }
1865
1866         FreeXid(xid);
1867         return rc;
1868 }
1869
1870 static int cifs_readpage_worker(struct file *file, struct page *page,
1871         loff_t *poffset)
1872 {
1873         char *read_data;
1874         int rc;
1875
1876         page_cache_get(page);
1877         read_data = kmap(page);
1878         /* for reads over a certain size could initiate async read ahead */
1879
1880         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1881
1882         if (rc < 0)
1883                 goto io_error;
1884         else
1885                 cFYI(1, ("Bytes read %d", rc));
1886
1887         file->f_path.dentry->d_inode->i_atime =
1888                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
1889
1890         if (PAGE_CACHE_SIZE > rc)
1891                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1892
1893         flush_dcache_page(page);
1894         SetPageUptodate(page);
1895         rc = 0;
1896
1897 io_error:
1898         kunmap(page);
1899         page_cache_release(page);
1900         return rc;
1901 }
1902
1903 static int cifs_readpage(struct file *file, struct page *page)
1904 {
1905         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1906         int rc = -EACCES;
1907         int xid;
1908
1909         xid = GetXid();
1910
1911         if (file->private_data == NULL) {
1912                 FreeXid(xid);
1913                 return -EBADF;
1914         }
1915
1916         cFYI(1, ("readpage %p at offset %d 0x%x\n",
1917                  page, (int)offset, (int)offset));
1918
1919         rc = cifs_readpage_worker(file, page, &offset);
1920
1921         unlock_page(page);
1922
1923         FreeXid(xid);
1924         return rc;
1925 }
1926
1927 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
1928 {
1929         struct cifsFileInfo *open_file;
1930
1931         read_lock(&GlobalSMBSeslock);
1932         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1933                 if (open_file->closePend)
1934                         continue;
1935                 if (open_file->pfile &&
1936                     ((open_file->pfile->f_flags & O_RDWR) ||
1937                      (open_file->pfile->f_flags & O_WRONLY))) {
1938                         read_unlock(&GlobalSMBSeslock);
1939                         return 1;
1940                 }
1941         }
1942         read_unlock(&GlobalSMBSeslock);
1943         return 0;
1944 }
1945
1946 /* We do not want to update the file size from server for inodes
1947    open for write - to avoid races with writepage extending
1948    the file - in the future we could consider allowing
1949    refreshing the inode only on increases in the file size
1950    but this is tricky to do without racing with writebehind
1951    page caching in the current Linux kernel design */
1952 int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
1953 {
1954         if (!cifsInode)
1955                 return 1;
1956
1957         if (is_inode_writable(cifsInode)) {
1958                 /* This inode is open for write at least once */
1959                 struct cifs_sb_info *cifs_sb;
1960
1961                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
1962                 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
1963                         /* since no page cache to corrupt on directio
1964                         we can change size safely */
1965                         return 1;
1966                 }
1967
1968                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
1969                         return 1;
1970
1971                 return 0;
1972         } else
1973                 return 1;
1974 }
1975
1976 static int cifs_prepare_write(struct file *file, struct page *page,
1977         unsigned from, unsigned to)
1978 {
1979         int rc = 0;
1980         loff_t i_size;
1981         loff_t offset;
1982
1983         cFYI(1, ("prepare write for page %p from %d to %d", page, from, to));
1984         if (PageUptodate(page))
1985                 return 0;
1986
1987         /* If we are writing a full page it will be up to date,
1988            no need to read from the server */
1989         if ((to == PAGE_CACHE_SIZE) && (from == 0)) {
1990                 SetPageUptodate(page);
1991                 return 0;
1992         }
1993
1994         offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1995         i_size = i_size_read(page->mapping->host);
1996
1997         if ((offset >= i_size) ||
1998             ((from == 0) && (offset + to) >= i_size)) {
1999                 /*
2000                  * We don't need to read data beyond the end of the file.
2001                  * zero it, and set the page uptodate
2002                  */
2003                 simple_prepare_write(file, page, from, to);
2004                 SetPageUptodate(page);
2005         } else if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2006                 /* might as well read a page, it is fast enough */
2007                 rc = cifs_readpage_worker(file, page, &offset);
2008         } else {
2009                 /* we could try using another file handle if there is one -
2010                    but how would we lock it to prevent close of that handle
2011                    racing with this read? In any case
2012                    this will be written out by commit_write so is fine */
2013         }
2014
2015         /* we do not need to pass errors back
2016            e.g. if we do not have read access to the file
2017            because cifs_commit_write will do the right thing.  -- shaggy */
2018
2019         return 0;
2020 }
2021
2022 const struct address_space_operations cifs_addr_ops = {
2023         .readpage = cifs_readpage,
2024         .readpages = cifs_readpages,
2025         .writepage = cifs_writepage,
2026         .writepages = cifs_writepages,
2027         .prepare_write = cifs_prepare_write,
2028         .commit_write = cifs_commit_write,
2029         .set_page_dirty = __set_page_dirty_nobuffers,
2030         /* .sync_page = cifs_sync_page, */
2031         /* .direct_IO = */
2032 };
2033
2034 /*
2035  * cifs_readpages requires the server to support a buffer large enough to
2036  * contain the header plus one complete page of data.  Otherwise, we need
2037  * to leave cifs_readpages out of the address space operations.
2038  */
2039 const struct address_space_operations cifs_addr_ops_smallbuf = {
2040         .readpage = cifs_readpage,
2041         .writepage = cifs_writepage,
2042         .writepages = cifs_writepages,
2043         .prepare_write = cifs_prepare_write,
2044         .commit_write = cifs_commit_write,
2045         .set_page_dirty = __set_page_dirty_nobuffers,
2046         /* .sync_page = cifs_sync_page, */
2047         /* .direct_IO = */
2048 };