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