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