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         read_lock(&GlobalSMBSeslock);
 549         if (list_empty(&(CIFS_I(inode)->openFileList))) {
 550                 cFYI(1, ("closing last open instance for inode %p", inode));
 551                 /* if the file is not open we do not know if we can cache info
 552                    on this inode, much less write behind and read ahead */
 553                 CIFS_I(inode)->clientCanCacheRead = FALSE;
 554                 CIFS_I(inode)->clientCanCacheAll  = FALSE;
 555         }
 556         read_unlock(&GlobalSMBSeslock);
 557         if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
 558                 rc = CIFS_I(inode)->write_behind_rc;
 559         FreeXid(xid);
 560         return rc;
 561 }
 562
 563 int cifs_closedir(struct inode *inode, struct file *file)
 564 {
 565         int rc = 0;
 566         int xid;
 567         struct cifsFileInfo *pCFileStruct =
 568             (struct cifsFileInfo *)file->private_data;
 569         char *ptmp;
 570
 571         cFYI(1, ("Closedir inode = 0x%p", inode));
 572
 573         xid = GetXid();
 574
 575         if (pCFileStruct) {
 576                 struct cifsTconInfo *pTcon;
 577                 struct cifs_sb_info *cifs_sb =
 578                         CIFS_SB(file->f_path.dentry->d_sb);
 579
 580                 pTcon = cifs_sb->tcon;
 581
 582                 cFYI(1, ("Freeing private data in close dir"));
 583                 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
 584                    (pCFileStruct->invalidHandle == FALSE)) {
 585                         pCFileStruct->invalidHandle = TRUE;
 586                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 587                         cFYI(1, ("Closing uncompleted readdir with rc %d",
 588                                  rc));
 589                         /* not much we can do if it fails anyway, ignore rc */
 590                         rc = 0;
 591                 }
 592                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 593                 if (ptmp) {
 594                         cFYI(1, ("closedir free smb buf in srch struct"));
 595                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 596                         if (pCFileStruct->srch_inf.smallBuf)
 597                                 cifs_small_buf_release(ptmp);
 598                         else
 599                                 cifs_buf_release(ptmp);
 600                 }
 601                 ptmp = pCFileStruct->search_resume_name;
 602                 if (ptmp) {
 603                         cFYI(1, ("closedir free resume name"));
 604                         pCFileStruct->search_resume_name = NULL;
 605                         kfree(ptmp);
 606                 }
 607                 kfree(file->private_data);
 608                 file->private_data = NULL;
 609         }
 610         /* BB can we lock the filestruct while this is going on? */
 611         FreeXid(xid);
 612         return rc;
 613 }
 614
 615 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
 616                                 __u64 offset, __u8 lockType)
 617 {
 618         struct cifsLockInfo *li =
 619                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 620         if (li == NULL)
 621                 return -ENOMEM;
 622         li->offset = offset;
 623         li->length = len;
 624         li->type = lockType;
 625         mutex_lock(&fid->lock_mutex);
 626         list_add(&li->llist, &fid->llist);
 627         mutex_unlock(&fid->lock_mutex);
 628         return 0;
 629 }
 630
 631 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
 632 {
 633         int rc, xid;
 634         __u32 numLock = 0;
 635         __u32 numUnlock = 0;
 636         __u64 length;
 637         int wait_flag = FALSE;
 638         struct cifs_sb_info *cifs_sb;
 639         struct cifsTconInfo *pTcon;
 640         __u16 netfid;
 641         __u8 lockType = LOCKING_ANDX_LARGE_FILES;
 642         int posix_locking;
 643
 644         length = 1 + pfLock->fl_end - pfLock->fl_start;
 645         rc = -EACCES;
 646         xid = GetXid();
 647
 648         cFYI(1, ("Lock parm: 0x%x flockflags: "
 649                  "0x%x flocktype: 0x%x start: %lld end: %lld",
 650                 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
 651                 pfLock->fl_end));
 652
 653         if (pfLock->fl_flags & FL_POSIX)
 654                 cFYI(1, ("Posix"));
 655         if (pfLock->fl_flags & FL_FLOCK)
 656                 cFYI(1, ("Flock"));
 657         if (pfLock->fl_flags & FL_SLEEP) {
 658                 cFYI(1, ("Blocking lock"));
 659                 wait_flag = TRUE;
 660         }
 661         if (pfLock->fl_flags & FL_ACCESS)
 662                 cFYI(1, ("Process suspended by mandatory locking - "
 663                          "not implemented yet"));
 664         if (pfLock->fl_flags & FL_LEASE)
 665                 cFYI(1, ("Lease on file - not implemented yet"));
 666         if (pfLock->fl_flags &
 667             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
 668                 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
 669
 670         if (pfLock->fl_type == F_WRLCK) {
 671                 cFYI(1, ("F_WRLCK "));
 672                 numLock = 1;
 673         } else if (pfLock->fl_type == F_UNLCK) {
 674                 cFYI(1, ("F_UNLCK"));
 675                 numUnlock = 1;
 676                 /* Check if unlock includes more than
 677                 one lock range */
 678         } else if (pfLock->fl_type == F_RDLCK) {
 679                 cFYI(1, ("F_RDLCK"));
 680                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 681                 numLock = 1;
 682         } else if (pfLock->fl_type == F_EXLCK) {
 683                 cFYI(1, ("F_EXLCK"));
 684                 numLock = 1;
 685         } else if (pfLock->fl_type == F_SHLCK) {
 686                 cFYI(1, ("F_SHLCK"));
 687                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 688                 numLock = 1;
 689         } else
 690                 cFYI(1, ("Unknown type of lock"));
 691
 692         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 693         pTcon = cifs_sb->tcon;
 694
 695         if (file->private_data == NULL) {
 696                 FreeXid(xid);
 697                 return -EBADF;
 698         }
 699         netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
 700
 701         posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
 702                         (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
 703
 704         /* BB add code here to normalize offset and length to
 705         account for negative length which we can not accept over the
 706         wire */
 707         if (IS_GETLK(cmd)) {
 708                 if (posix_locking) {
 709                         int posix_lock_type;
 710                         if (lockType & LOCKING_ANDX_SHARED_LOCK)
 711                                 posix_lock_type = CIFS_RDLCK;
 712                         else
 713                                 posix_lock_type = CIFS_WRLCK;
 714                         rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
 715                                         length, pfLock,
 716                                         posix_lock_type, wait_flag);
 717                         FreeXid(xid);
 718                         return rc;
 719                 }
 720
 721                 /* BB we could chain these into one lock request BB */
 722                 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
 723                                  0, 1, lockType, 0 /* wait flag */ );
 724                 if (rc == 0) {
 725                         rc = CIFSSMBLock(xid, pTcon, netfid, length,
 726                                          pfLock->fl_start, 1 /* numUnlock */ ,
 727                                          0 /* numLock */ , lockType,
 728                                          0 /* wait flag */ );
 729                         pfLock->fl_type = F_UNLCK;
 730                         if (rc != 0)
 731                                 cERROR(1, ("Error unlocking previously locked "
 732                                            "range %d during test of lock", rc));
 733                         rc = 0;
 734
 735                 } else {
 736                         /* if rc == ERR_SHARING_VIOLATION ? */
 737                         rc = 0; /* do not change lock type to unlock
 738                                    since range in use */
 739                 }
 740
 741                 FreeXid(xid);
 742                 return rc;
 743         }
 744
 745         if (!numLock && !numUnlock) {
 746                 /* if no lock or unlock then nothing
 747                 to do since we do not know what it is */
 748                 FreeXid(xid);
 749                 return -EOPNOTSUPP;
 750         }
 751
 752         if (posix_locking) {
 753                 int posix_lock_type;
 754                 if (lockType & LOCKING_ANDX_SHARED_LOCK)
 755                         posix_lock_type = CIFS_RDLCK;
 756                 else
 757                         posix_lock_type = CIFS_WRLCK;
 758
 759                 if (numUnlock == 1)
 760                         posix_lock_type = CIFS_UNLCK;
 761
 762                 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
 763                                       length, pfLock,
 764                                       posix_lock_type, wait_flag);
 765         } else {
 766                 struct cifsFileInfo *fid =
 767                         (struct cifsFileInfo *)file->private_data;
 768
 769                 if (numLock) {
 770                         rc = CIFSSMBLock(xid, pTcon, netfid, length,
 771                                         pfLock->fl_start,
 772                                         0, numLock, lockType, wait_flag);
 773
 774                         if (rc == 0) {
 775                                 /* For Windows locks we must store them. */
 776                                 rc = store_file_lock(fid, length,
 777                                                 pfLock->fl_start, lockType);
 778                         }
 779                 } else if (numUnlock) {
 780                         /* For each stored lock that this unlock overlaps
 781                            completely, unlock it. */
 782                         int stored_rc = 0;
 783                         struct cifsLockInfo *li, *tmp;
 784
 785                         rc = 0;
 786                         mutex_lock(&fid->lock_mutex);
 787                         list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
 788                                 if (pfLock->fl_start <= li->offset &&
 789                                                 (pfLock->fl_start + length) >=
 790                                                 (li->offset + li->length)) {
 791                                         stored_rc = CIFSSMBLock(xid, pTcon,
 792                                                         netfid,
 793                                                         li->length, li->offset,
 794                                                         1, 0, li->type, FALSE);
 795                                         if (stored_rc)
 796                                                 rc = stored_rc;
 797
 798                                         list_del(&li->llist);
 799                                         kfree(li);
 800                                 }
 801                         }
 802                         mutex_unlock(&fid->lock_mutex);
 803                 }
 804         }
 805
 806         if (pfLock->fl_flags & FL_POSIX)
 807                 posix_lock_file_wait(file, pfLock);
 808         FreeXid(xid);
 809         return rc;
 810 }
 811
 812 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
 813         size_t write_size, loff_t *poffset)
 814 {
 815         int rc = 0;
 816         unsigned int bytes_written = 0;
 817         unsigned int total_written;
 818         struct cifs_sb_info *cifs_sb;
 819         struct cifsTconInfo *pTcon;
 820         int xid, long_op;
 821         struct cifsFileInfo *open_file;
 822
 823         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 824
 825         pTcon = cifs_sb->tcon;
 826
 827         /* cFYI(1,
 828            (" write %d bytes to offset %lld of %s", write_size,
 829            *poffset, file->f_path.dentry->d_name.name)); */
 830
 831         if (file->private_data == NULL)
 832                 return -EBADF;
 833         open_file = (struct cifsFileInfo *) file->private_data;
 834
 835         xid = GetXid();
 836
 837         if (*poffset > file->f_path.dentry->d_inode->i_size)
 838                 long_op = 2; /* writes past end of file can take a long time */
 839         else
 840                 long_op = 1;
 841
 842         for (total_written = 0; write_size > total_written;
 843              total_written += bytes_written) {
 844                 rc = -EAGAIN;
 845                 while (rc == -EAGAIN) {
 846                         if (file->private_data == NULL) {
 847                                 /* file has been closed on us */
 848                                 FreeXid(xid);
 849                         /* if we have gotten here we have written some data
 850                            and blocked, and the file has been freed on us while
 851                            we blocked so return what we managed to write */
 852                                 return total_written;
 853                         }
 854                         if (open_file->closePend) {
 855                                 FreeXid(xid);
 856                                 if (total_written)
 857                                         return total_written;
 858                                 else
 859                                         return -EBADF;
 860                         }
 861                         if (open_file->invalidHandle) {
 862                                 /* we could deadlock if we called
 863                                    filemap_fdatawait from here so tell
 864                                    reopen_file not to flush data to server
 865                                    now */
 866                                 rc = cifs_reopen_file(file, FALSE);
 867                                 if (rc != 0)
 868                                         break;
 869                         }
 870
 871                         rc = CIFSSMBWrite(xid, pTcon,
 872                                 open_file->netfid,
 873                                 min_t(const int, cifs_sb->wsize,
 874                                       write_size - total_written),
 875                                 *poffset, &bytes_written,
 876                                 NULL, write_data + total_written, long_op);
 877                 }
 878                 if (rc || (bytes_written == 0)) {
 879                         if (total_written)
 880                                 break;
 881                         else {
 882                                 FreeXid(xid);
 883                                 return rc;
 884                         }
 885                 } else
 886                         *poffset += bytes_written;
 887                 long_op = FALSE; /* subsequent writes fast -
 888                                     15 seconds is plenty */
 889         }
 890
 891         cifs_stats_bytes_written(pTcon, total_written);
 892
 893         /* since the write may have blocked check these pointers again */
 894         if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
 895                 struct inode *inode = file->f_path.dentry->d_inode;
 896 /* Do not update local mtime - server will set its actual value on write
 897  *              inode->i_ctime = inode->i_mtime =
 898  *                      current_fs_time(inode->i_sb);*/
 899                 if (total_written > 0) {
 900                         spin_lock(&inode->i_lock);
 901                         if (*poffset > file->f_path.dentry->d_inode->i_size)
 902                                 i_size_write(file->f_path.dentry->d_inode,
 903                                         *poffset);
 904                         spin_unlock(&inode->i_lock);
 905                 }
 906                 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
 907         }
 908         FreeXid(xid);
 909         return total_written;
 910 }
 911
 912 static ssize_t cifs_write(struct file *file, const char *write_data,
 913         size_t write_size, loff_t *poffset)
 914 {
 915         int rc = 0;
 916         unsigned int bytes_written = 0;
 917         unsigned int total_written;
 918         struct cifs_sb_info *cifs_sb;
 919         struct cifsTconInfo *pTcon;
 920         int xid, long_op;
 921         struct cifsFileInfo *open_file;
 922
 923         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 924
 925         pTcon = cifs_sb->tcon;
 926
 927         cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
 928            *poffset, file->f_path.dentry->d_name.name));
 929
 930         if (file->private_data == NULL)
 931                 return -EBADF;
 932         open_file = (struct cifsFileInfo *)file->private_data;
 933
 934         xid = GetXid();
 935
 936         if (*poffset > file->f_path.dentry->d_inode->i_size)
 937                 long_op = 2; /* writes past end of file can take a long time */
 938         else
 939                 long_op = 1;
 940
 941         for (total_written = 0; write_size > total_written;
 942              total_written += bytes_written) {
 943                 rc = -EAGAIN;
 944                 while (rc == -EAGAIN) {
 945                         if (file->private_data == NULL) {
 946                                 /* file has been closed on us */
 947                                 FreeXid(xid);
 948                         /* if we have gotten here we have written some data
 949                            and blocked, and the file has been freed on us
 950                            while we blocked so return what we managed to
 951                            write */
 952                                 return total_written;
 953                         }
 954                         if (open_file->closePend) {
 955                                 FreeXid(xid);
 956                                 if (total_written)
 957                                         return total_written;
 958                                 else
 959                                         return -EBADF;
 960                         }
 961                         if (open_file->invalidHandle) {
 962                                 /* we could deadlock if we called
 963                                    filemap_fdatawait from here so tell
 964                                    reopen_file not to flush data to
 965                                    server now */
 966                                 rc = cifs_reopen_file(file, FALSE);
 967                                 if (rc != 0)
 968                                         break;
 969                         }
 970                         if (experimEnabled || (pTcon->ses->server &&
 971                                 ((pTcon->ses->server->secMode &
 972                                 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 973                                 == 0))) {
 974                                 struct kvec iov[2];
 975                                 unsigned int len;
 976
 977                                 len = min((size_t)cifs_sb->wsize,
 978                                           write_size - total_written);
 979                                 /* iov[0] is reserved for smb header */
 980                                 iov[1].iov_base = (char *)write_data +
 981                                                   total_written;
 982                                 iov[1].iov_len = len;
 983                                 rc = CIFSSMBWrite2(xid, pTcon,
 984                                                 open_file->netfid, len,
 985                                                 *poffset, &bytes_written,
 986                                                 iov, 1, long_op);
 987                         } else
 988                                 rc = CIFSSMBWrite(xid, pTcon,
 989                                          open_file->netfid,
 990                                          min_t(const int, cifs_sb->wsize,
 991                                                write_size - total_written),
 992                                          *poffset, &bytes_written,
 993                                          write_data + total_written,
 994                                          NULL, long_op);
 995                 }
 996                 if (rc || (bytes_written == 0)) {
 997                         if (total_written)
 998                                 break;
 999                         else {
1000                                 FreeXid(xid);
1001                                 return rc;
1002                         }
1003                 } else
1004                         *poffset += bytes_written;
1005                 long_op = FALSE; /* subsequent writes fast -
1006                                     15 seconds is plenty */
1007         }
1008
1009         cifs_stats_bytes_written(pTcon, total_written);
1010
1011         /* since the write may have blocked check these pointers again */
1012         if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1013 /*BB We could make this contingent on superblock ATIME flag too */
1014 /*              file->f_path.dentry->d_inode->i_ctime =
1015                 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1016                 if (total_written > 0) {
1017                         spin_lock(&file->f_path.dentry->d_inode->i_lock);
1018                         if (*poffset > file->f_path.dentry->d_inode->i_size)
1019                                 i_size_write(file->f_path.dentry->d_inode,
1020                                              *poffset);
1021                         spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1022                 }
1023                 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1024         }
1025         FreeXid(xid);
1026         return total_written;
1027 }
1028
1029 #ifdef CONFIG_CIFS_EXPERIMENTAL
1030 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1031 {
1032         struct cifsFileInfo *open_file = NULL;
1033
1034         read_lock(&GlobalSMBSeslock);
1035         /* we could simply get the first_list_entry since write-only entries
1036            are always at the end of the list but since the first entry might
1037            have a close pending, we go through the whole list */
1038         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1039                 if (open_file->closePend)
1040                         continue;
1041                 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1042                     (open_file->pfile->f_flags & O_RDONLY))) {
1043                         if (!open_file->invalidHandle) {
1044                                 /* found a good file */
1045                                 /* lock it so it will not be closed on us */
1046                                 atomic_inc(&open_file->wrtPending);
1047                                 read_unlock(&GlobalSMBSeslock);
1048                                 return open_file;
1049                         } /* else might as well continue, and look for
1050                              another, or simply have the caller reopen it
1051                              again rather than trying to fix this handle */
1052                 } else /* write only file */
1053                         break; /* write only files are last so must be done */
1054         }
1055         read_unlock(&GlobalSMBSeslock);
1056         return NULL;
1057 }
1058 #endif
1059
1060 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1061 {
1062         struct cifsFileInfo *open_file;
1063         int rc;
1064
1065         /* Having a null inode here (because mapping->host was set to zero by
1066         the VFS or MM) should not happen but we had reports of on oops (due to
1067         it being zero) during stress testcases so we need to check for it */
1068
1069         if (cifs_inode == NULL) {
1070                 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1071                 dump_stack();
1072                 return NULL;
1073         }
1074
1075         read_lock(&GlobalSMBSeslock);
1076 refind_writable:
1077         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1078                 if (open_file->closePend)
1079                         continue;
1080                 if (open_file->pfile &&
1081                     ((open_file->pfile->f_flags & O_RDWR) ||
1082                      (open_file->pfile->f_flags & O_WRONLY))) {
1083                         atomic_inc(&open_file->wrtPending);
1084
1085                         if (!open_file->invalidHandle) {
1086                                 /* found a good writable file */
1087                                 read_unlock(&GlobalSMBSeslock);
1088                                 return open_file;
1089                         }
1090
1091                         read_unlock(&GlobalSMBSeslock);
1092                         /* Had to unlock since following call can block */
1093                         rc = cifs_reopen_file(open_file->pfile, FALSE);
1094                         if (!rc) {
1095                                 if (!open_file->closePend)
1096                                         return open_file;
1097                                 else { /* start over in case this was deleted */
1098                                        /* since the list could be modified */
1099                                         read_lock(&GlobalSMBSeslock);
1100                                         atomic_dec(&open_file->wrtPending);
1101                                         goto refind_writable;
1102                                 }
1103                         }
1104
1105                         /* if it fails, try another handle if possible -
1106                         (we can not do this if closePending since
1107                         loop could be modified - in which case we
1108                         have to start at the beginning of the list
1109                         again. Note that it would be bad
1110                         to hold up writepages here (rather than
1111                         in caller) with continuous retries */
1112                         cFYI(1, ("wp failed on reopen file"));
1113                         read_lock(&GlobalSMBSeslock);
1114                         /* can not use this handle, no write
1115                            pending on this one after all */
1116                         atomic_dec(&open_file->wrtPending);
1117
1118                         if (open_file->closePend) /* list could have changed */
1119                                 goto refind_writable;
1120                         /* else we simply continue to the next entry. Thus
1121                            we do not loop on reopen errors.  If we
1122                            can not reopen the file, for example if we
1123                            reconnected to a server with another client
1124                            racing to delete or lock the file we would not
1125                            make progress if we restarted before the beginning
1126                            of the loop here. */
1127                 }
1128         }
1129         read_unlock(&GlobalSMBSeslock);
1130         return NULL;
1131 }
1132
1133 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1134 {
1135         struct address_space *mapping = page->mapping;
1136         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1137         char *write_data;
1138         int rc = -EFAULT;
1139         int bytes_written = 0;
1140         struct cifs_sb_info *cifs_sb;
1141         struct cifsTconInfo *pTcon;
1142         struct inode *inode;
1143         struct cifsFileInfo *open_file;
1144
1145         if (!mapping || !mapping->host)
1146                 return -EFAULT;
1147
1148         inode = page->mapping->host;
1149         cifs_sb = CIFS_SB(inode->i_sb);
1150         pTcon = cifs_sb->tcon;
1151
1152         offset += (loff_t)from;
1153         write_data = kmap(page);
1154         write_data += from;
1155
1156         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1157                 kunmap(page);
1158                 return -EIO;
1159         }
1160
1161         /* racing with truncate? */
1162         if (offset > mapping->host->i_size) {
1163                 kunmap(page);
1164                 return 0; /* don't care */
1165         }
1166
1167         /* check to make sure that we are not extending the file */
1168         if (mapping->host->i_size - offset < (loff_t)to)
1169                 to = (unsigned)(mapping->host->i_size - offset);
1170
1171         open_file = find_writable_file(CIFS_I(mapping->host));
1172         if (open_file) {
1173                 bytes_written = cifs_write(open_file->pfile, write_data,
1174                                            to-from, &offset);
1175                 atomic_dec(&open_file->wrtPending);
1176                 /* Does mm or vfs already set times? */
1177                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1178                 if ((bytes_written > 0) && (offset)) {
1179                         rc = 0;
1180                 } else if (bytes_written < 0) {
1181                         if (rc != -EBADF)
1182                                 rc = bytes_written;
1183                 }
1184         } else {
1185                 cFYI(1, ("No writeable filehandles for inode"));
1186                 rc = -EIO;
1187         }
1188
1189         kunmap(page);
1190         return rc;
1191 }
1192
1193 static int cifs_writepages(struct address_space *mapping,
1194                            struct writeback_control *wbc)
1195 {
1196         struct backing_dev_info *bdi = mapping->backing_dev_info;
1197         unsigned int bytes_to_write;
1198         unsigned int bytes_written;
1199         struct cifs_sb_info *cifs_sb;
1200         int done = 0;
1201         pgoff_t end;
1202         pgoff_t index;
1203         int range_whole = 0;
1204         struct kvec *iov;
1205         int len;
1206         int n_iov = 0;
1207         pgoff_t next;
1208         int nr_pages;
1209         __u64 offset = 0;
1210         struct cifsFileInfo *open_file;
1211         struct page *page;
1212         struct pagevec pvec;
1213         int rc = 0;
1214         int scanned = 0;
1215         int xid;
1216
1217         cifs_sb = CIFS_SB(mapping->host->i_sb);
1218
1219         /*
1220          * If wsize is smaller that the page cache size, default to writing
1221          * one page at a time via cifs_writepage
1222          */
1223         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1224                 return generic_writepages(mapping, wbc);
1225
1226         if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1227                 if (cifs_sb->tcon->ses->server->secMode &
1228                                 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1229                         if (!experimEnabled)
1230                                 return generic_writepages(mapping, wbc);
1231
1232         iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1233         if (iov == NULL)
1234                 return generic_writepages(mapping, wbc);
1235
1236
1237         /*
1238          * BB: Is this meaningful for a non-block-device file system?
1239          * If it is, we should test it again after we do I/O
1240          */
1241         if (wbc->nonblocking && bdi_write_congested(bdi)) {
1242                 wbc->encountered_congestion = 1;
1243                 kfree(iov);
1244                 return 0;
1245         }
1246
1247         xid = GetXid();
1248
1249         pagevec_init(&pvec, 0);
1250         if (wbc->range_cyclic) {
1251                 index = mapping->writeback_index; /* Start from prev offset */
1252                 end = -1;
1253         } else {
1254                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1255                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1256                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1257                         range_whole = 1;
1258                 scanned = 1;
1259         }
1260 retry:
1261         while (!done && (index <= end) &&
1262                (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1263                         PAGECACHE_TAG_DIRTY,
1264                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1265                 int first;
1266                 unsigned int i;
1267
1268                 first = -1;
1269                 next = 0;
1270                 n_iov = 0;
1271                 bytes_to_write = 0;
1272
1273                 for (i = 0; i < nr_pages; i++) {
1274                         page = pvec.pages[i];
1275                         /*
1276                          * At this point we hold neither mapping->tree_lock nor
1277                          * lock on the page itself: the page may be truncated or
1278                          * invalidated (changing page->mapping to NULL), or even
1279                          * swizzled back from swapper_space to tmpfs file
1280                          * mapping
1281                          */
1282
1283                         if (first < 0)
1284                                 lock_page(page);
1285                         else if (TestSetPageLocked(page))
1286                                 break;
1287
1288                         if (unlikely(page->mapping != mapping)) {
1289                                 unlock_page(page);
1290                                 break;
1291                         }
1292
1293                         if (!wbc->range_cyclic && page->index > end) {
1294                                 done = 1;
1295                                 unlock_page(page);
1296                                 break;
1297                         }
1298
1299                         if (next && (page->index != next)) {
1300                                 /* Not next consecutive page */
1301                                 unlock_page(page);
1302                                 break;
1303                         }
1304
1305                         if (wbc->sync_mode != WB_SYNC_NONE)
1306                                 wait_on_page_writeback(page);
1307
1308                         if (PageWriteback(page) ||
1309                                         !clear_page_dirty_for_io(page)) {
1310                                 unlock_page(page);
1311                                 break;
1312                         }
1313
1314                         /*
1315                          * This actually clears the dirty bit in the radix tree.
1316                          * See cifs_writepage() for more commentary.
1317                          */
1318                         set_page_writeback(page);
1319
1320                         if (page_offset(page) >= mapping->host->i_size) {
1321                                 done = 1;
1322                                 unlock_page(page);
1323                                 end_page_writeback(page);
1324                                 break;
1325                         }
1326
1327                         /*
1328                          * BB can we get rid of this?  pages are held by pvec
1329                          */
1330                         page_cache_get(page);
1331
1332                         len = min(mapping->host->i_size - page_offset(page),
1333                                   (loff_t)PAGE_CACHE_SIZE);
1334
1335                         /* reserve iov[0] for the smb header */
1336                         n_iov++;
1337                         iov[n_iov].iov_base = kmap(page);
1338                         iov[n_iov].iov_len = len;
1339                         bytes_to_write += len;
1340
1341                         if (first < 0) {
1342                                 first = i;
1343                                 offset = page_offset(page);
1344                         }
1345                         next = page->index + 1;
1346                         if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1347                                 break;
1348                 }
1349                 if (n_iov) {
1350                         /* Search for a writable handle every time we call
1351                          * CIFSSMBWrite2.  We can't rely on the last handle
1352                          * we used to still be valid
1353                          */
1354                         open_file = find_writable_file(CIFS_I(mapping->host));
1355                         if (!open_file) {
1356                                 cERROR(1, ("No writable handles for inode"));
1357                                 rc = -EBADF;
1358                         } else {
1359                                 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1360                                                    open_file->netfid,
1361                                                    bytes_to_write, offset,
1362                                                    &bytes_written, iov, n_iov,
1363                                                    1);
1364                                 atomic_dec(&open_file->wrtPending);
1365                                 if (rc || bytes_written < bytes_to_write) {
1366                                         cERROR(1, ("Write2 ret %d, wrote %d",
1367                                                   rc, bytes_written));
1368                                         /* BB what if continued retry is
1369                                            requested via mount flags? */
1370                                         set_bit(AS_EIO, &mapping->flags);
1371                                 } else {
1372                                         cifs_stats_bytes_written(cifs_sb->tcon,
1373                                                                  bytes_written);
1374                                 }
1375                         }
1376                         for (i = 0; i < n_iov; i++) {
1377                                 page = pvec.pages[first + i];
1378                                 /* Should we also set page error on
1379                                 success rc but too little data written? */
1380                                 /* BB investigate retry logic on temporary
1381                                 server crash cases and how recovery works
1382                                 when page marked as error */
1383                                 if (rc)
1384                                         SetPageError(page);
1385                                 kunmap(page);
1386                                 unlock_page(page);
1387                                 end_page_writeback(page);
1388                                 page_cache_release(page);
1389                         }
1390                         if ((wbc->nr_to_write -= n_iov) <= 0)
1391                                 done = 1;
1392                         index = next;
1393                 }
1394                 pagevec_release(&pvec);
1395         }
1396         if (!scanned && !done) {
1397                 /*
1398                  * We hit the last page and there is more work to be done: wrap
1399                  * back to the start of the file
1400                  */
1401                 scanned = 1;
1402                 index = 0;
1403                 goto retry;
1404         }
1405         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1406                 mapping->writeback_index = index;
1407
1408         FreeXid(xid);
1409         kfree(iov);
1410         return rc;
1411 }
1412
1413 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1414 {
1415         int rc = -EFAULT;
1416         int xid;
1417
1418         xid = GetXid();
1419 /* BB add check for wbc flags */
1420         page_cache_get(page);
1421         if (!PageUptodate(page)) {
1422                 cFYI(1, ("ppw - page not up to date"));
1423         }
1424
1425         /*
1426          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1427          *
1428          * A writepage() implementation always needs to do either this,
1429          * or re-dirty the page with "redirty_page_for_writepage()" in
1430          * the case of a failure.
1431          *
1432          * Just unlocking the page will cause the radix tree tag-bits
1433          * to fail to update with the state of the page correctly.
1434          */
1435         set_page_writeback(page);
1436         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1437         SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1438         unlock_page(page);
1439         end_page_writeback(page);
1440         page_cache_release(page);
1441         FreeXid(xid);
1442         return rc;
1443 }
1444
1445 static int cifs_commit_write(struct file *file, struct page *page,
1446         unsigned offset, unsigned to)
1447 {
1448         int xid;
1449         int rc = 0;
1450         struct inode *inode = page->mapping->host;
1451         loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1452         char *page_data;
1453
1454         xid = GetXid();
1455         cFYI(1, ("commit write for page %p up to position %lld for %d",
1456                  page, position, to));
1457         spin_lock(&inode->i_lock);
1458         if (position > inode->i_size) {
1459                 i_size_write(inode, position);
1460         }
1461         spin_unlock(&inode->i_lock);
1462         if (!PageUptodate(page)) {
1463                 position =  ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1464                 /* can not rely on (or let) writepage write this data */
1465                 if (to < offset) {
1466                         cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1467                                 offset, to));
1468                         FreeXid(xid);
1469                         return rc;
1470                 }
1471                 /* this is probably better than directly calling
1472                    partialpage_write since in this function the file handle is
1473                    known which we might as well leverage */
1474                 /* BB check if anything else missing out of ppw
1475                    such as updating last write time */
1476                 page_data = kmap(page);
1477                 rc = cifs_write(file, page_data + offset, to-offset,
1478                                 &position);
1479                 if (rc > 0)
1480                         rc = 0;
1481                 /* else if (rc < 0) should we set writebehind rc? */
1482                 kunmap(page);
1483         } else {
1484                 set_page_dirty(page);
1485         }
1486
1487         FreeXid(xid);
1488         return rc;
1489 }
1490
1491 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1492 {
1493         int xid;
1494         int rc = 0;
1495         struct inode *inode = file->f_path.dentry->d_inode;
1496
1497         xid = GetXid();
1498
1499         cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1500                 dentry->d_name.name, datasync));
1501
1502         rc = filemap_fdatawrite(inode->i_mapping);
1503         if (rc == 0)
1504                 CIFS_I(inode)->write_behind_rc = 0;
1505         FreeXid(xid);
1506         return rc;
1507 }
1508
1509 /* static void cifs_sync_page(struct page *page)
1510 {
1511         struct address_space *mapping;
1512         struct inode *inode;
1513         unsigned long index = page->index;
1514         unsigned int rpages = 0;
1515         int rc = 0;
1516
1517         cFYI(1, ("sync page %p",page));
1518         mapping = page->mapping;
1519         if (!mapping)
1520                 return 0;
1521         inode = mapping->host;
1522         if (!inode)
1523                 return; */
1524
1525 /*      fill in rpages then
1526         result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1527
1528 /*      cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1529
1530 #if 0
1531         if (rc < 0)
1532                 return rc;
1533         return 0;
1534 #endif
1535 } */
1536
1537 /*
1538  * As file closes, flush all cached write data for this inode checking
1539  * for write behind errors.
1540  */
1541 int cifs_flush(struct file *file, fl_owner_t id)
1542 {
1543         struct inode *inode = file->f_path.dentry->d_inode;
1544         int rc = 0;
1545
1546         /* Rather than do the steps manually:
1547            lock the inode for writing
1548            loop through pages looking for write behind data (dirty pages)
1549            coalesce into contiguous 16K (or smaller) chunks to write to server
1550            send to server (prefer in parallel)
1551            deal with writebehind errors
1552            unlock inode for writing
1553            filemapfdatawrite appears easier for the time being */
1554
1555         rc = filemap_fdatawrite(inode->i_mapping);
1556         if (!rc) /* reset wb rc if we were able to write out dirty pages */
1557                 CIFS_I(inode)->write_behind_rc = 0;
1558
1559         cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
1560
1561         return rc;
1562 }
1563
1564 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1565         size_t read_size, loff_t *poffset)
1566 {
1567         int rc = -EACCES;
1568         unsigned int bytes_read = 0;
1569         unsigned int total_read = 0;
1570         unsigned int current_read_size;
1571         struct cifs_sb_info *cifs_sb;
1572         struct cifsTconInfo *pTcon;
1573         int xid;
1574         struct cifsFileInfo *open_file;
1575         char *smb_read_data;
1576         char __user *current_offset;
1577         struct smb_com_read_rsp *pSMBr;
1578
1579         xid = GetXid();
1580         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1581         pTcon = cifs_sb->tcon;
1582
1583         if (file->private_data == NULL) {
1584                 FreeXid(xid);
1585                 return -EBADF;
1586         }
1587         open_file = (struct cifsFileInfo *)file->private_data;
1588
1589         if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1590                 cFYI(1, ("attempting read on write only file instance"));
1591         }
1592         for (total_read = 0, current_offset = read_data;
1593              read_size > total_read;
1594              total_read += bytes_read, current_offset += bytes_read) {
1595                 current_read_size = min_t(const int, read_size - total_read,
1596                                           cifs_sb->rsize);
1597                 rc = -EAGAIN;
1598                 smb_read_data = NULL;
1599                 while (rc == -EAGAIN) {
1600                         int buf_type = CIFS_NO_BUFFER;
1601                         if ((open_file->invalidHandle) &&
1602                             (!open_file->closePend)) {
1603                                 rc = cifs_reopen_file(file, TRUE);
1604                                 if (rc != 0)
1605                                         break;
1606                         }
1607                         rc = CIFSSMBRead(xid, pTcon,
1608                                          open_file->netfid,
1609                                          current_read_size, *poffset,
1610                                          &bytes_read, &smb_read_data,
1611                                          &buf_type);
1612                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1613                         if (smb_read_data) {
1614                                 if (copy_to_user(current_offset,
1615                                                 smb_read_data +
1616                                                 4 /* RFC1001 length field */ +
1617                                                 le16_to_cpu(pSMBr->DataOffset),
1618                                                 bytes_read)) {
1619                                         rc = -EFAULT;
1620                                 }
1621
1622                                 if (buf_type == CIFS_SMALL_BUFFER)
1623                                         cifs_small_buf_release(smb_read_data);
1624                                 else if (buf_type == CIFS_LARGE_BUFFER)
1625                                         cifs_buf_release(smb_read_data);
1626                                 smb_read_data = NULL;
1627                         }
1628                 }
1629                 if (rc || (bytes_read == 0)) {
1630                         if (total_read) {
1631                                 break;
1632                         } else {
1633                                 FreeXid(xid);
1634                                 return rc;
1635                         }
1636                 } else {
1637                         cifs_stats_bytes_read(pTcon, bytes_read);
1638                         *poffset += bytes_read;
1639                 }
1640         }
1641         FreeXid(xid);
1642         return total_read;
1643 }
1644
1645
1646 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1647         loff_t *poffset)
1648 {
1649         int rc = -EACCES;
1650         unsigned int bytes_read = 0;
1651         unsigned int total_read;
1652         unsigned int current_read_size;
1653         struct cifs_sb_info *cifs_sb;
1654         struct cifsTconInfo *pTcon;
1655         int xid;
1656         char *current_offset;
1657         struct cifsFileInfo *open_file;
1658         int buf_type = CIFS_NO_BUFFER;
1659
1660         xid = GetXid();
1661         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1662         pTcon = cifs_sb->tcon;
1663
1664         if (file->private_data == NULL) {
1665                 FreeXid(xid);
1666                 return -EBADF;
1667         }
1668         open_file = (struct cifsFileInfo *)file->private_data;
1669
1670         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1671                 cFYI(1, ("attempting read on write only file instance"));
1672
1673         for (total_read = 0, current_offset = read_data;
1674              read_size > total_read;
1675              total_read += bytes_read, current_offset += bytes_read) {
1676                 current_read_size = min_t(const int, read_size - total_read,
1677                                           cifs_sb->rsize);
1678                 /* For windows me and 9x we do not want to request more
1679                 than it negotiated since it will refuse the read then */
1680                 if ((pTcon->ses) &&
1681                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1682                         current_read_size = min_t(const int, current_read_size,
1683                                         pTcon->ses->server->maxBuf - 128);
1684                 }
1685                 rc = -EAGAIN;
1686                 while (rc == -EAGAIN) {
1687                         if ((open_file->invalidHandle) &&
1688                             (!open_file->closePend)) {
1689                                 rc = cifs_reopen_file(file, TRUE);
1690                                 if (rc != 0)
1691                                         break;
1692                         }
1693                         rc = CIFSSMBRead(xid, pTcon,
1694                                          open_file->netfid,
1695                                          current_read_size, *poffset,
1696                                          &bytes_read, &current_offset,
1697                                          &buf_type);
1698                 }
1699                 if (rc || (bytes_read == 0)) {
1700                         if (total_read) {
1701                                 break;
1702                         } else {
1703                                 FreeXid(xid);
1704                                 return rc;
1705                         }
1706                 } else {
1707                         cifs_stats_bytes_read(pTcon, total_read);
1708                         *poffset += bytes_read;
1709                 }
1710         }
1711         FreeXid(xid);
1712         return total_read;
1713 }
1714
1715 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1716 {
1717         struct dentry *dentry = file->f_path.dentry;
1718         int rc, xid;
1719
1720         xid = GetXid();
1721         rc = cifs_revalidate(dentry);
1722         if (rc) {
1723                 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1724                 FreeXid(xid);
1725                 return rc;
1726         }
1727         rc = generic_file_mmap(file, vma);
1728         FreeXid(xid);
1729         return rc;
1730 }
1731
1732
1733 static void cifs_copy_cache_pages(struct address_space *mapping,
1734         struct list_head *pages, int bytes_read, char *data,
1735         struct pagevec *plru_pvec)
1736 {
1737         struct page *page;
1738         char *target;
1739
1740         while (bytes_read > 0) {
1741                 if (list_empty(pages))
1742                         break;
1743
1744                 page = list_entry(pages->prev, struct page, lru);
1745                 list_del(&page->lru);
1746
1747                 if (add_to_page_cache(page, mapping, page->index,
1748                                       GFP_KERNEL)) {
1749                         page_cache_release(page);
1750                         cFYI(1, ("Add page cache failed"));
1751                         data += PAGE_CACHE_SIZE;
1752                         bytes_read -= PAGE_CACHE_SIZE;
1753                         continue;
1754                 }
1755
1756                 target = kmap_atomic(page, KM_USER0);
1757
1758                 if (PAGE_CACHE_SIZE > bytes_read) {
1759                         memcpy(target, data, bytes_read);
1760                         /* zero the tail end of this partial page */
1761                         memset(target + bytes_read, 0,
1762                                PAGE_CACHE_SIZE - bytes_read);
1763                         bytes_read = 0;
1764                 } else {
1765                         memcpy(target, data, PAGE_CACHE_SIZE);
1766                         bytes_read -= PAGE_CACHE_SIZE;
1767                 }
1768                 kunmap_atomic(target, KM_USER0);
1769
1770                 flush_dcache_page(page);
1771                 SetPageUptodate(page);
1772                 unlock_page(page);
1773                 if (!pagevec_add(plru_pvec, page))
1774                         __pagevec_lru_add(plru_pvec);
1775                 data += PAGE_CACHE_SIZE;
1776         }
1777         return;
1778 }
1779
1780 static int cifs_readpages(struct file *file, struct address_space *mapping,
1781         struct list_head *page_list, unsigned num_pages)
1782 {
1783         int rc = -EACCES;
1784         int xid;
1785         loff_t offset;
1786         struct page *page;
1787         struct cifs_sb_info *cifs_sb;
1788         struct cifsTconInfo *pTcon;
1789         unsigned int bytes_read = 0;
1790         unsigned int read_size, i;
1791         char *smb_read_data = NULL;
1792         struct smb_com_read_rsp *pSMBr;
1793         struct pagevec lru_pvec;
1794         struct cifsFileInfo *open_file;
1795         int buf_type = CIFS_NO_BUFFER;
1796
1797         xid = GetXid();
1798         if (file->private_data == NULL) {
1799                 FreeXid(xid);
1800                 return -EBADF;
1801         }
1802         open_file = (struct cifsFileInfo *)file->private_data;
1803         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1804         pTcon = cifs_sb->tcon;
1805
1806         pagevec_init(&lru_pvec, 0);
1807 #ifdef CONFIG_CIFS_DEBUG2
1808                 cFYI(1, ("rpages: num pages %d", num_pages));
1809 #endif
1810         for (i = 0; i < num_pages; ) {
1811                 unsigned contig_pages;
1812                 struct page *tmp_page;
1813                 unsigned long expected_index;
1814
1815                 if (list_empty(page_list))
1816                         break;
1817
1818                 page = list_entry(page_list->prev, struct page, lru);
1819                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1820
1821                 /* count adjacent pages that we will read into */
1822                 contig_pages = 0;
1823                 expected_index =
1824                         list_entry(page_list->prev, struct page, lru)->index;
1825                 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1826                         if (tmp_page->index == expected_index) {
1827                                 contig_pages++;
1828                                 expected_index++;
1829                         } else
1830                                 break;
1831                 }
1832                 if (contig_pages + i >  num_pages)
1833                         contig_pages = num_pages - i;
1834
1835                 /* for reads over a certain size could initiate async
1836                    read ahead */
1837
1838                 read_size = contig_pages * PAGE_CACHE_SIZE;
1839                 /* Read size needs to be in multiples of one page */
1840                 read_size = min_t(const unsigned int, read_size,
1841                                   cifs_sb->rsize & PAGE_CACHE_MASK);
1842 #ifdef CONFIG_CIFS_DEBUG2
1843                 cFYI(1, ("rpages: read size 0x%x  contiguous pages %d",
1844                                 read_size, contig_pages));
1845 #endif
1846                 rc = -EAGAIN;
1847                 while (rc == -EAGAIN) {
1848                         if ((open_file->invalidHandle) &&
1849                             (!open_file->closePend)) {
1850                                 rc = cifs_reopen_file(file, TRUE);
1851                                 if (rc != 0)
1852                                         break;
1853                         }
1854
1855                         rc = CIFSSMBRead(xid, pTcon,
1856                                          open_file->netfid,
1857                                          read_size, offset,
1858                                          &bytes_read, &smb_read_data,
1859                                          &buf_type);
1860                         /* BB more RC checks ? */
1861                         if (rc == -EAGAIN) {
1862                                 if (smb_read_data) {
1863                                         if (buf_type == CIFS_SMALL_BUFFER)
1864                                                 cifs_small_buf_release(smb_read_data);
1865                                         else if (buf_type == CIFS_LARGE_BUFFER)
1866                                                 cifs_buf_release(smb_read_data);
1867                                         smb_read_data = NULL;
1868                                 }
1869                         }
1870                 }
1871                 if ((rc < 0) || (smb_read_data == NULL)) {
1872                         cFYI(1, ("Read error in readpages: %d", rc));
1873                         break;
1874                 } else if (bytes_read > 0) {
1875                         task_io_account_read(bytes_read);
1876                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1877                         cifs_copy_cache_pages(mapping, page_list, bytes_read,
1878                                 smb_read_data + 4 /* RFC1001 hdr */ +
1879                                 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1880
1881                         i +=  bytes_read >> PAGE_CACHE_SHIFT;
1882                         cifs_stats_bytes_read(pTcon, bytes_read);
1883                         if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1884                                 i++; /* account for partial page */
1885
1886                                 /* server copy of file can have smaller size
1887                                    than client */
1888                                 /* BB do we need to verify this common case ?
1889                                    this case is ok - if we are at server EOF
1890                                    we will hit it on next read */
1891
1892                                 /* break; */
1893                         }
1894                 } else {
1895                         cFYI(1, ("No bytes read (%d) at offset %lld . "
1896                                  "Cleaning remaining pages from readahead list",
1897                                  bytes_read, offset));
1898                         /* BB turn off caching and do new lookup on
1899                            file size at server? */
1900                         break;
1901                 }
1902                 if (smb_read_data) {
1903                         if (buf_type == CIFS_SMALL_BUFFER)
1904                                 cifs_small_buf_release(smb_read_data);
1905                         else if (buf_type == CIFS_LARGE_BUFFER)
1906                                 cifs_buf_release(smb_read_data);
1907                         smb_read_data = NULL;
1908                 }
1909                 bytes_read = 0;
1910         }
1911
1912         pagevec_lru_add(&lru_pvec);
1913
1914 /* need to free smb_read_data buf before exit */
1915         if (smb_read_data) {
1916                 if (buf_type == CIFS_SMALL_BUFFER)
1917                         cifs_small_buf_release(smb_read_data);
1918                 else if (buf_type == CIFS_LARGE_BUFFER)
1919                         cifs_buf_release(smb_read_data);
1920                 smb_read_data = NULL;
1921         }
1922
1923         FreeXid(xid);
1924         return rc;
1925 }
1926
1927 static int cifs_readpage_worker(struct file *file, struct page *page,
1928         loff_t *poffset)
1929 {
1930         char *read_data;
1931         int rc;
1932
1933         page_cache_get(page);
1934         read_data = kmap(page);
1935         /* for reads over a certain size could initiate async read ahead */
1936
1937         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1938
1939         if (rc < 0)
1940                 goto io_error;
1941         else
1942                 cFYI(1, ("Bytes read %d", rc));
1943
1944         file->f_path.dentry->d_inode->i_atime =
1945                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
1946
1947         if (PAGE_CACHE_SIZE > rc)
1948                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1949
1950         flush_dcache_page(page);
1951         SetPageUptodate(page);
1952         rc = 0;
1953
1954 io_error:
1955         kunmap(page);
1956         page_cache_release(page);
1957         return rc;
1958 }
1959
1960 static int cifs_readpage(struct file *file, struct page *page)
1961 {
1962         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1963         int rc = -EACCES;
1964         int xid;
1965
1966         xid = GetXid();
1967
1968         if (file->private_data == NULL) {
1969                 FreeXid(xid);
1970                 return -EBADF;
1971         }
1972
1973         cFYI(1, ("readpage %p at offset %d 0x%x\n",
1974                  page, (int)offset, (int)offset));
1975
1976         rc = cifs_readpage_worker(file, page, &offset);
1977
1978         unlock_page(page);
1979
1980         FreeXid(xid);
1981         return rc;
1982 }
1983
1984 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
1985 {
1986         struct cifsFileInfo *open_file;
1987
1988         read_lock(&GlobalSMBSeslock);
1989         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1990                 if (open_file->closePend)
1991                         continue;
1992                 if (open_file->pfile &&
1993                     ((open_file->pfile->f_flags & O_RDWR) ||
1994                      (open_file->pfile->f_flags & O_WRONLY))) {
1995                         read_unlock(&GlobalSMBSeslock);
1996                         return 1;
1997                 }
1998         }
1999         read_unlock(&GlobalSMBSeslock);
2000         return 0;
2001 }
2002
2003 /* We do not want to update the file size from server for inodes
2004    open for write - to avoid races with writepage extending
2005    the file - in the future we could consider allowing
2006    refreshing the inode only on increases in the file size
2007    but this is tricky to do without racing with writebehind
2008    page caching in the current Linux kernel design */
2009 int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2010 {
2011         if (!cifsInode)
2012                 return 1;
2013
2014         if (is_inode_writable(cifsInode)) {
2015                 /* This inode is open for write at least once */
2016                 struct cifs_sb_info *cifs_sb;
2017
2018                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2019                 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
2020                         /* since no page cache to corrupt on directio
2021                         we can change size safely */
2022                         return 1;
2023                 }
2024
2025                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2026                         return 1;
2027
2028                 return 0;
2029         } else
2030                 return 1;
2031 }
2032
2033 static int cifs_prepare_write(struct file *file, struct page *page,
2034         unsigned from, unsigned to)
2035 {
2036         int rc = 0;
2037         loff_t i_size;
2038         loff_t offset;
2039
2040         cFYI(1, ("prepare write for page %p from %d to %d", page, from, to));
2041         if (PageUptodate(page))
2042                 return 0;
2043
2044         /* If we are writing a full page it will be up to date,
2045            no need to read from the server */
2046         if ((to == PAGE_CACHE_SIZE) && (from == 0)) {
2047                 SetPageUptodate(page);
2048                 return 0;
2049         }
2050
2051         offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2052         i_size = i_size_read(page->mapping->host);
2053
2054         if ((offset >= i_size) ||
2055             ((from == 0) && (offset + to) >= i_size)) {
2056                 /*
2057                  * We don't need to read data beyond the end of the file.
2058                  * zero it, and set the page uptodate
2059                  */
2060                 simple_prepare_write(file, page, from, to);
2061                 SetPageUptodate(page);
2062         } else if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2063                 /* might as well read a page, it is fast enough */
2064                 rc = cifs_readpage_worker(file, page, &offset);
2065         } else {
2066                 /* we could try using another file handle if there is one -
2067                    but how would we lock it to prevent close of that handle
2068                    racing with this read? In any case
2069                    this will be written out by commit_write so is fine */
2070         }
2071
2072         /* we do not need to pass errors back
2073            e.g. if we do not have read access to the file
2074            because cifs_commit_write will do the right thing.  -- shaggy */
2075
2076         return 0;
2077 }
2078
2079 const struct address_space_operations cifs_addr_ops = {
2080         .readpage = cifs_readpage,
2081         .readpages = cifs_readpages,
2082         .writepage = cifs_writepage,
2083         .writepages = cifs_writepages,
2084         .prepare_write = cifs_prepare_write,
2085         .commit_write = cifs_commit_write,
2086         .set_page_dirty = __set_page_dirty_nobuffers,
2087         /* .sync_page = cifs_sync_page, */
2088         /* .direct_IO = */
2089 };
2090
2091 /*
2092  * cifs_readpages requires the server to support a buffer large enough to
2093  * contain the header plus one complete page of data.  Otherwise, we need
2094  * to leave cifs_readpages out of the address space operations.
2095  */
2096 const struct address_space_operations cifs_addr_ops_smallbuf = {
2097         .readpage = cifs_readpage,
2098         .writepage = cifs_writepage,
2099         .writepages = cifs_writepages,
2100         .prepare_write = cifs_prepare_write,
2101         .commit_write = cifs_commit_write,
2102         .set_page_dirty = __set_page_dirty_nobuffers,
2103         /* .sync_page = cifs_sync_page, */
2104         /* .direct_IO = */
2105 };