fs/cifs/file.c

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