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