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, int *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;
 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                                                         oflags);
 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 (cifs_sb->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                                         file->f_flags);
 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 = cifs_sb->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 = cifs_sb->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;
 657                 struct cifs_sb_info *cifs_sb =
 658                         CIFS_SB(file->f_path.dentry->d_sb);
 659
 660                 pTcon = cifs_sb->tcon;
 661
 662                 cFYI(1, "Freeing private data in close dir");
 663                 write_lock(&GlobalSMBSeslock);
 664                 if (!pCFileStruct->srch_inf.endOfSearch &&
 665                     !pCFileStruct->invalidHandle) {
 666                         pCFileStruct->invalidHandle = true;
 667                         write_unlock(&GlobalSMBSeslock);
 668                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 669                         cFYI(1, "Closing uncompleted readdir with rc %d",
 670                                  rc);
 671                         /* not much we can do if it fails anyway, ignore rc */
 672                         rc = 0;
 673                 } else
 674                         write_unlock(&GlobalSMBSeslock);
 675                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 676                 if (ptmp) {
 677                         cFYI(1, "closedir free smb buf in srch struct");
 678                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 679                         if (pCFileStruct->srch_inf.smallBuf)
 680                                 cifs_small_buf_release(ptmp);
 681                         else
 682                                 cifs_buf_release(ptmp);
 683                 }
 684                 kfree(file->private_data);
 685                 file->private_data = NULL;
 686         }
 687         /* BB can we lock the filestruct while this is going on? */
 688         FreeXid(xid);
 689         return rc;
 690 }
 691
 692 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
 693                                 __u64 offset, __u8 lockType)
 694 {
 695         struct cifsLockInfo *li =
 696                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 697         if (li == NULL)
 698                 return -ENOMEM;
 699         li->offset = offset;
 700         li->length = len;
 701         li->type = lockType;
 702         mutex_lock(&fid->lock_mutex);
 703         list_add(&li->llist, &fid->llist);
 704         mutex_unlock(&fid->lock_mutex);
 705         return 0;
 706 }
 707
 708 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
 709 {
 710         int rc, xid;
 711         __u32 numLock = 0;
 712         __u32 numUnlock = 0;
 713         __u64 length;
 714         bool wait_flag = false;
 715         struct cifs_sb_info *cifs_sb;
 716         struct cifsTconInfo *tcon;
 717         __u16 netfid;
 718         __u8 lockType = LOCKING_ANDX_LARGE_FILES;
 719         bool posix_locking = 0;
 720
 721         length = 1 + pfLock->fl_end - pfLock->fl_start;
 722         rc = -EACCES;
 723         xid = GetXid();
 724
 725         cFYI(1, "Lock parm: 0x%x flockflags: "
 726                  "0x%x flocktype: 0x%x start: %lld end: %lld",
 727                 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
 728                 pfLock->fl_end);
 729
 730         if (pfLock->fl_flags & FL_POSIX)
 731                 cFYI(1, "Posix");
 732         if (pfLock->fl_flags & FL_FLOCK)
 733                 cFYI(1, "Flock");
 734         if (pfLock->fl_flags & FL_SLEEP) {
 735                 cFYI(1, "Blocking lock");
 736                 wait_flag = true;
 737         }
 738         if (pfLock->fl_flags & FL_ACCESS)
 739                 cFYI(1, "Process suspended by mandatory locking - "
 740                          "not implemented yet");
 741         if (pfLock->fl_flags & FL_LEASE)
 742                 cFYI(1, "Lease on file - not implemented yet");
 743         if (pfLock->fl_flags &
 744             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
 745                 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
 746
 747         if (pfLock->fl_type == F_WRLCK) {
 748                 cFYI(1, "F_WRLCK ");
 749                 numLock = 1;
 750         } else if (pfLock->fl_type == F_UNLCK) {
 751                 cFYI(1, "F_UNLCK");
 752                 numUnlock = 1;
 753                 /* Check if unlock includes more than
 754                 one lock range */
 755         } else if (pfLock->fl_type == F_RDLCK) {
 756                 cFYI(1, "F_RDLCK");
 757                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 758                 numLock = 1;
 759         } else if (pfLock->fl_type == F_EXLCK) {
 760                 cFYI(1, "F_EXLCK");
 761                 numLock = 1;
 762         } else if (pfLock->fl_type == F_SHLCK) {
 763                 cFYI(1, "F_SHLCK");
 764                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 765                 numLock = 1;
 766         } else
 767                 cFYI(1, "Unknown type of lock");
 768
 769         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 770         tcon = cifs_sb->tcon;
 771
 772         if (file->private_data == NULL) {
 773                 rc = -EBADF;
 774                 FreeXid(xid);
 775                 return rc;
 776         }
 777         netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
 778
 779         if ((tcon->ses->capabilities & CAP_UNIX) &&
 780             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 781             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 782                 posix_locking = 1;
 783         /* BB add code here to normalize offset and length to
 784         account for negative length which we can not accept over the
 785         wire */
 786         if (IS_GETLK(cmd)) {
 787                 if (posix_locking) {
 788                         int posix_lock_type;
 789                         if (lockType & LOCKING_ANDX_SHARED_LOCK)
 790                                 posix_lock_type = CIFS_RDLCK;
 791                         else
 792                                 posix_lock_type = CIFS_WRLCK;
 793                         rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
 794                                         length, pfLock,
 795                                         posix_lock_type, wait_flag);
 796                         FreeXid(xid);
 797                         return rc;
 798                 }
 799
 800                 /* BB we could chain these into one lock request BB */
 801                 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
 802                                  0, 1, lockType, 0 /* wait flag */ );
 803                 if (rc == 0) {
 804                         rc = CIFSSMBLock(xid, tcon, netfid, length,
 805                                          pfLock->fl_start, 1 /* numUnlock */ ,
 806                                          0 /* numLock */ , lockType,
 807                                          0 /* wait flag */ );
 808                         pfLock->fl_type = F_UNLCK;
 809                         if (rc != 0)
 810                                 cERROR(1, "Error unlocking previously locked "
 811                                            "range %d during test of lock", rc);
 812                         rc = 0;
 813
 814                 } else {
 815                         /* if rc == ERR_SHARING_VIOLATION ? */
 816                         rc = 0;
 817
 818                         if (lockType & LOCKING_ANDX_SHARED_LOCK) {
 819                                 pfLock->fl_type = F_WRLCK;
 820                         } else {
 821                                 rc = CIFSSMBLock(xid, tcon, netfid, length,
 822                                         pfLock->fl_start, 0, 1,
 823                                         lockType | LOCKING_ANDX_SHARED_LOCK,
 824                                         0 /* wait flag */);
 825                                 if (rc == 0) {
 826                                         rc = CIFSSMBLock(xid, tcon, netfid,
 827                                                 length, pfLock->fl_start, 1, 0,
 828                                                 lockType |
 829                                                 LOCKING_ANDX_SHARED_LOCK,
 830                                                 0 /* wait flag */);
 831                                         pfLock->fl_type = F_RDLCK;
 832                                         if (rc != 0)
 833                                                 cERROR(1, "Error unlocking "
 834                                                 "previously locked range %d "
 835                                                 "during test of lock", rc);
 836                                         rc = 0;
 837                                 } else {
 838                                         pfLock->fl_type = F_WRLCK;
 839                                         rc = 0;
 840                                 }
 841                         }
 842                 }
 843
 844                 FreeXid(xid);
 845                 return rc;
 846         }
 847
 848         if (!numLock && !numUnlock) {
 849                 /* if no lock or unlock then nothing
 850                 to do since we do not know what it is */
 851                 FreeXid(xid);
 852                 return -EOPNOTSUPP;
 853         }
 854
 855         if (posix_locking) {
 856                 int posix_lock_type;
 857                 if (lockType & LOCKING_ANDX_SHARED_LOCK)
 858                         posix_lock_type = CIFS_RDLCK;
 859                 else
 860                         posix_lock_type = CIFS_WRLCK;
 861
 862                 if (numUnlock == 1)
 863                         posix_lock_type = CIFS_UNLCK;
 864
 865                 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
 866                                       length, pfLock,
 867                                       posix_lock_type, wait_flag);
 868         } else {
 869                 struct cifsFileInfo *fid = file->private_data;
 870
 871                 if (numLock) {
 872                         rc = CIFSSMBLock(xid, tcon, netfid, length,
 873                                         pfLock->fl_start,
 874                                         0, numLock, lockType, wait_flag);
 875
 876                         if (rc == 0) {
 877                                 /* For Windows locks we must store them. */
 878                                 rc = store_file_lock(fid, length,
 879                                                 pfLock->fl_start, lockType);
 880                         }
 881                 } else if (numUnlock) {
 882                         /* For each stored lock that this unlock overlaps
 883                            completely, unlock it. */
 884                         int stored_rc = 0;
 885                         struct cifsLockInfo *li, *tmp;
 886
 887                         rc = 0;
 888                         mutex_lock(&fid->lock_mutex);
 889                         list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
 890                                 if (pfLock->fl_start <= li->offset &&
 891                                                 (pfLock->fl_start + length) >=
 892                                                 (li->offset + li->length)) {
 893                                         stored_rc = CIFSSMBLock(xid, tcon,
 894                                                         netfid,
 895                                                         li->length, li->offset,
 896                                                         1, 0, li->type, false);
 897                                         if (stored_rc)
 898                                                 rc = stored_rc;
 899                                         else {
 900                                                 list_del(&li->llist);
 901                                                 kfree(li);
 902                                         }
 903                                 }
 904                         }
 905                         mutex_unlock(&fid->lock_mutex);
 906                 }
 907         }
 908
 909         if (pfLock->fl_flags & FL_POSIX)
 910                 posix_lock_file_wait(file, pfLock);
 911         FreeXid(xid);
 912         return rc;
 913 }
 914
 915 /*
 916  * Set the timeout on write requests past EOF. For some servers (Windows)
 917  * these calls can be very long.
 918  *
 919  * If we're writing >10M past the EOF we give a 180s timeout. Anything less
 920  * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
 921  * The 10M cutoff is totally arbitrary. A better scheme for this would be
 922  * welcome if someone wants to suggest one.
 923  *
 924  * We may be able to do a better job with this if there were some way to
 925  * declare that a file should be sparse.
 926  */
 927 static int
 928 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
 929 {
 930         if (offset <= cifsi->server_eof)
 931                 return CIFS_STD_OP;
 932         else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
 933                 return CIFS_VLONG_OP;
 934         else
 935                 return CIFS_LONG_OP;
 936 }
 937
 938 /* update the file size (if needed) after a write */
 939 static void
 940 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
 941                       unsigned int bytes_written)
 942 {
 943         loff_t end_of_write = offset + bytes_written;
 944
 945         if (end_of_write > cifsi->server_eof)
 946                 cifsi->server_eof = end_of_write;
 947 }
 948
 949 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
 950         size_t write_size, loff_t *poffset)
 951 {
 952         int rc = 0;
 953         unsigned int bytes_written = 0;
 954         unsigned int total_written;
 955         struct cifs_sb_info *cifs_sb;
 956         struct cifsTconInfo *pTcon;
 957         int xid, long_op;
 958         struct cifsFileInfo *open_file;
 959         struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
 960
 961         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 962
 963         pTcon = cifs_sb->tcon;
 964
 965         /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
 966            *poffset, file->f_path.dentry->d_name.name); */
 967
 968         if (file->private_data == NULL)
 969                 return -EBADF;
 970         open_file = file->private_data;
 971
 972         rc = generic_write_checks(file, poffset, &write_size, 0);
 973         if (rc)
 974                 return rc;
 975
 976         xid = GetXid();
 977
 978         long_op = cifs_write_timeout(cifsi, *poffset);
 979         for (total_written = 0; write_size > total_written;
 980              total_written += bytes_written) {
 981                 rc = -EAGAIN;
 982                 while (rc == -EAGAIN) {
 983                         if (file->private_data == NULL) {
 984                                 /* file has been closed on us */
 985                                 FreeXid(xid);
 986                         /* if we have gotten here we have written some data
 987                            and blocked, and the file has been freed on us while
 988                            we blocked so return what we managed to write */
 989                                 return total_written;
 990                         }
 991                         if (open_file->closePend) {
 992                                 FreeXid(xid);
 993                                 if (total_written)
 994                                         return total_written;
 995                                 else
 996                                         return -EBADF;
 997                         }
 998                         if (open_file->invalidHandle) {
 999                                 /* we could deadlock if we called
1000                                    filemap_fdatawait from here so tell
1001                                    reopen_file not to flush data to server
1002                                    now */
1003                                 rc = cifs_reopen_file(file, false);
1004                                 if (rc != 0)
1005                                         break;
1006                         }
1007
1008                         rc = CIFSSMBWrite(xid, pTcon,
1009                                 open_file->netfid,
1010                                 min_t(const int, cifs_sb->wsize,
1011                                       write_size - total_written),
1012                                 *poffset, &bytes_written,
1013                                 NULL, write_data + total_written, long_op);
1014                 }
1015                 if (rc || (bytes_written == 0)) {
1016                         if (total_written)
1017                                 break;
1018                         else {
1019                                 FreeXid(xid);
1020                                 return rc;
1021                         }
1022                 } else {
1023                         cifs_update_eof(cifsi, *poffset, bytes_written);
1024                         *poffset += bytes_written;
1025                 }
1026                 long_op = CIFS_STD_OP; /* subsequent writes fast -
1027                                     15 seconds is plenty */
1028         }
1029
1030         cifs_stats_bytes_written(pTcon, total_written);
1031
1032         /* since the write may have blocked check these pointers again */
1033         if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1034                 struct inode *inode = file->f_path.dentry->d_inode;
1035 /* Do not update local mtime - server will set its actual value on write
1036  *              inode->i_ctime = inode->i_mtime =
1037  *                      current_fs_time(inode->i_sb);*/
1038                 if (total_written > 0) {
1039                         spin_lock(&inode->i_lock);
1040                         if (*poffset > file->f_path.dentry->d_inode->i_size)
1041                                 i_size_write(file->f_path.dentry->d_inode,
1042                                         *poffset);
1043                         spin_unlock(&inode->i_lock);
1044                 }
1045                 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1046         }
1047         FreeXid(xid);
1048         return total_written;
1049 }
1050
1051 static ssize_t cifs_write(struct file *file, const char *write_data,
1052                           size_t write_size, loff_t *poffset)
1053 {
1054         int rc = 0;
1055         unsigned int bytes_written = 0;
1056         unsigned int total_written;
1057         struct cifs_sb_info *cifs_sb;
1058         struct cifsTconInfo *pTcon;
1059         int xid, long_op;
1060         struct cifsFileInfo *open_file;
1061         struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1062
1063         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1064
1065         pTcon = cifs_sb->tcon;
1066
1067         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1068            *poffset, file->f_path.dentry->d_name.name);
1069
1070         if (file->private_data == NULL)
1071                 return -EBADF;
1072         open_file = file->private_data;
1073
1074         xid = GetXid();
1075
1076         long_op = cifs_write_timeout(cifsi, *poffset);
1077         for (total_written = 0; write_size > total_written;
1078              total_written += bytes_written) {
1079                 rc = -EAGAIN;
1080                 while (rc == -EAGAIN) {
1081                         if (file->private_data == NULL) {
1082                                 /* file has been closed on us */
1083                                 FreeXid(xid);
1084                         /* if we have gotten here we have written some data
1085                            and blocked, and the file has been freed on us
1086                            while we blocked so return what we managed to
1087                            write */
1088                                 return total_written;
1089                         }
1090                         if (open_file->closePend) {
1091                                 FreeXid(xid);
1092                                 if (total_written)
1093                                         return total_written;
1094                                 else
1095                                         return -EBADF;
1096                         }
1097                         if (open_file->invalidHandle) {
1098                                 /* we could deadlock if we called
1099                                    filemap_fdatawait from here so tell
1100                                    reopen_file not to flush data to
1101                                    server now */
1102                                 rc = cifs_reopen_file(file, false);
1103                                 if (rc != 0)
1104                                         break;
1105                         }
1106                         if (experimEnabled || (pTcon->ses->server &&
1107                                 ((pTcon->ses->server->secMode &
1108                                 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1109                                 == 0))) {
1110                                 struct kvec iov[2];
1111                                 unsigned int len;
1112
1113                                 len = min((size_t)cifs_sb->wsize,
1114                                           write_size - total_written);
1115                                 /* iov[0] is reserved for smb header */
1116                                 iov[1].iov_base = (char *)write_data +
1117                                                   total_written;
1118                                 iov[1].iov_len = len;
1119                                 rc = CIFSSMBWrite2(xid, pTcon,
1120                                                 open_file->netfid, len,
1121                                                 *poffset, &bytes_written,
1122                                                 iov, 1, long_op);
1123                         } else
1124                                 rc = CIFSSMBWrite(xid, pTcon,
1125                                          open_file->netfid,
1126                                          min_t(const int, cifs_sb->wsize,
1127                                                write_size - total_written),
1128                                          *poffset, &bytes_written,
1129                                          write_data + total_written,
1130                                          NULL, long_op);
1131                 }
1132                 if (rc || (bytes_written == 0)) {
1133                         if (total_written)
1134                                 break;
1135                         else {
1136                                 FreeXid(xid);
1137                                 return rc;
1138                         }
1139                 } else {
1140                         cifs_update_eof(cifsi, *poffset, bytes_written);
1141                         *poffset += bytes_written;
1142                 }
1143                 long_op = CIFS_STD_OP; /* subsequent writes fast -
1144                                     15 seconds is plenty */
1145         }
1146
1147         cifs_stats_bytes_written(pTcon, total_written);
1148
1149         /* since the write may have blocked check these pointers again */
1150         if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1151 /*BB We could make this contingent on superblock ATIME flag too */
1152 /*              file->f_path.dentry->d_inode->i_ctime =
1153                 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1154                 if (total_written > 0) {
1155                         spin_lock(&file->f_path.dentry->d_inode->i_lock);
1156                         if (*poffset > file->f_path.dentry->d_inode->i_size)
1157                                 i_size_write(file->f_path.dentry->d_inode,
1158                                              *poffset);
1159                         spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1160                 }
1161                 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1162         }
1163         FreeXid(xid);
1164         return total_written;
1165 }
1166
1167 #ifdef CONFIG_CIFS_EXPERIMENTAL
1168 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1169 {
1170         struct cifsFileInfo *open_file = NULL;
1171
1172         read_lock(&GlobalSMBSeslock);
1173         /* we could simply get the first_list_entry since write-only entries
1174            are always at the end of the list but since the first entry might
1175            have a close pending, we go through the whole list */
1176         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1177                 if (open_file->closePend)
1178                         continue;
1179                 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1180                     (open_file->pfile->f_flags & O_RDONLY))) {
1181                         if (!open_file->invalidHandle) {
1182                                 /* found a good file */
1183                                 /* lock it so it will not be closed on us */
1184                                 cifsFileInfo_get(open_file);
1185                                 read_unlock(&GlobalSMBSeslock);
1186                                 return open_file;
1187                         } /* else might as well continue, and look for
1188                              another, or simply have the caller reopen it
1189                              again rather than trying to fix this handle */
1190                 } else /* write only file */
1191                         break; /* write only files are last so must be done */
1192         }
1193         read_unlock(&GlobalSMBSeslock);
1194         return NULL;
1195 }
1196 #endif
1197
1198 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1199 {
1200         struct cifsFileInfo *open_file;
1201         bool any_available = false;
1202         int rc;
1203
1204         /* Having a null inode here (because mapping->host was set to zero by
1205         the VFS or MM) should not happen but we had reports of on oops (due to
1206         it being zero) during stress testcases so we need to check for it */
1207
1208         if (cifs_inode == NULL) {
1209                 cERROR(1, "Null inode passed to cifs_writeable_file");
1210                 dump_stack();
1211                 return NULL;
1212         }
1213
1214         read_lock(&GlobalSMBSeslock);
1215 refind_writable:
1216         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1217                 if (open_file->closePend ||
1218                     (!any_available && open_file->pid != current->tgid))
1219                         continue;
1220
1221                 if (open_file->pfile &&
1222                     ((open_file->pfile->f_flags & O_RDWR) ||
1223                      (open_file->pfile->f_flags & O_WRONLY))) {
1224                         cifsFileInfo_get(open_file);
1225
1226                         if (!open_file->invalidHandle) {
1227                                 /* found a good writable file */
1228                                 read_unlock(&GlobalSMBSeslock);
1229                                 return open_file;
1230                         }
1231
1232                         read_unlock(&GlobalSMBSeslock);
1233                         /* Had to unlock since following call can block */
1234                         rc = cifs_reopen_file(open_file->pfile, false);
1235                         if (!rc) {
1236                                 if (!open_file->closePend)
1237                                         return open_file;
1238                                 else { /* start over in case this was deleted */
1239                                        /* since the list could be modified */
1240                                         read_lock(&GlobalSMBSeslock);
1241                                         cifsFileInfo_put(open_file);
1242                                         goto refind_writable;
1243                                 }
1244                         }
1245
1246                         /* if it fails, try another handle if possible -
1247                         (we can not do this if closePending since
1248                         loop could be modified - in which case we
1249                         have to start at the beginning of the list
1250                         again. Note that it would be bad
1251                         to hold up writepages here (rather than
1252                         in caller) with continuous retries */
1253                         cFYI(1, "wp failed on reopen file");
1254                         read_lock(&GlobalSMBSeslock);
1255                         /* can not use this handle, no write
1256                            pending on this one after all */
1257                         cifsFileInfo_put(open_file);
1258
1259                         if (open_file->closePend) /* list could have changed */
1260                                 goto refind_writable;
1261                         /* else we simply continue to the next entry. Thus
1262                            we do not loop on reopen errors.  If we
1263                            can not reopen the file, for example if we
1264                            reconnected to a server with another client
1265                            racing to delete or lock the file we would not
1266                            make progress if we restarted before the beginning
1267                            of the loop here. */
1268                 }
1269         }
1270         /* couldn't find useable FH with same pid, try any available */
1271         if (!any_available) {
1272                 any_available = true;
1273                 goto refind_writable;
1274         }
1275         read_unlock(&GlobalSMBSeslock);
1276         return NULL;
1277 }
1278
1279 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1280 {
1281         struct address_space *mapping = page->mapping;
1282         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1283         char *write_data;
1284         int rc = -EFAULT;
1285         int bytes_written = 0;
1286         struct cifs_sb_info *cifs_sb;
1287         struct cifsTconInfo *pTcon;
1288         struct inode *inode;
1289         struct cifsFileInfo *open_file;
1290
1291         if (!mapping || !mapping->host)
1292                 return -EFAULT;
1293
1294         inode = page->mapping->host;
1295         cifs_sb = CIFS_SB(inode->i_sb);
1296         pTcon = cifs_sb->tcon;
1297
1298         offset += (loff_t)from;
1299         write_data = kmap(page);
1300         write_data += from;
1301
1302         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1303                 kunmap(page);
1304                 return -EIO;
1305         }
1306
1307         /* racing with truncate? */
1308         if (offset > mapping->host->i_size) {
1309                 kunmap(page);
1310                 return 0; /* don't care */
1311         }
1312
1313         /* check to make sure that we are not extending the file */
1314         if (mapping->host->i_size - offset < (loff_t)to)
1315                 to = (unsigned)(mapping->host->i_size - offset);
1316
1317         open_file = find_writable_file(CIFS_I(mapping->host));
1318         if (open_file) {
1319                 bytes_written = cifs_write(open_file->pfile, write_data,
1320                                            to-from, &offset);
1321                 cifsFileInfo_put(open_file);
1322                 /* Does mm or vfs already set times? */
1323                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1324                 if ((bytes_written > 0) && (offset))
1325                         rc = 0;
1326                 else if (bytes_written < 0)
1327                         rc = bytes_written;
1328         } else {
1329                 cFYI(1, "No writeable filehandles for inode");
1330                 rc = -EIO;
1331         }
1332
1333         kunmap(page);
1334         return rc;
1335 }
1336
1337 static int cifs_writepages(struct address_space *mapping,
1338                            struct writeback_control *wbc)
1339 {
1340         struct backing_dev_info *bdi = mapping->backing_dev_info;
1341         unsigned int bytes_to_write;
1342         unsigned int bytes_written;
1343         struct cifs_sb_info *cifs_sb;
1344         int done = 0;
1345         pgoff_t end;
1346         pgoff_t index;
1347         int range_whole = 0;
1348         struct kvec *iov;
1349         int len;
1350         int n_iov = 0;
1351         pgoff_t next;
1352         int nr_pages;
1353         __u64 offset = 0;
1354         struct cifsFileInfo *open_file;
1355         struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1356         struct page *page;
1357         struct pagevec pvec;
1358         int rc = 0;
1359         int scanned = 0;
1360         int xid, long_op;
1361
1362         cifs_sb = CIFS_SB(mapping->host->i_sb);
1363
1364         /*
1365          * If wsize is smaller that the page cache size, default to writing
1366          * one page at a time via cifs_writepage
1367          */
1368         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1369                 return generic_writepages(mapping, wbc);
1370
1371         if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1372                 if (cifs_sb->tcon->ses->server->secMode &
1373                                 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1374                         if (!experimEnabled)
1375                                 return generic_writepages(mapping, wbc);
1376
1377         iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1378         if (iov == NULL)
1379                 return generic_writepages(mapping, wbc);
1380
1381
1382         /*
1383          * BB: Is this meaningful for a non-block-device file system?
1384          * If it is, we should test it again after we do I/O
1385          */
1386         if (wbc->nonblocking && bdi_write_congested(bdi)) {
1387                 wbc->encountered_congestion = 1;
1388                 kfree(iov);
1389                 return 0;
1390         }
1391
1392         xid = GetXid();
1393
1394         pagevec_init(&pvec, 0);
1395         if (wbc->range_cyclic) {
1396                 index = mapping->writeback_index; /* Start from prev offset */
1397                 end = -1;
1398         } else {
1399                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1400                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1401                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1402                         range_whole = 1;
1403                 scanned = 1;
1404         }
1405 retry:
1406         while (!done && (index <= end) &&
1407                (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1408                         PAGECACHE_TAG_DIRTY,
1409                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1410                 int first;
1411                 unsigned int i;
1412
1413                 first = -1;
1414                 next = 0;
1415                 n_iov = 0;
1416                 bytes_to_write = 0;
1417
1418                 for (i = 0; i < nr_pages; i++) {
1419                         page = pvec.pages[i];
1420                         /*
1421                          * At this point we hold neither mapping->tree_lock nor
1422                          * lock on the page itself: the page may be truncated or
1423                          * invalidated (changing page->mapping to NULL), or even
1424                          * swizzled back from swapper_space to tmpfs file
1425                          * mapping
1426                          */
1427
1428                         if (first < 0)
1429                                 lock_page(page);
1430                         else if (!trylock_page(page))
1431                                 break;
1432
1433                         if (unlikely(page->mapping != mapping)) {
1434                                 unlock_page(page);
1435                                 break;
1436                         }
1437
1438                         if (!wbc->range_cyclic && page->index > end) {
1439                                 done = 1;
1440                                 unlock_page(page);
1441                                 break;
1442                         }
1443
1444                         if (next && (page->index != next)) {
1445                                 /* Not next consecutive page */
1446                                 unlock_page(page);
1447                                 break;
1448                         }
1449
1450                         if (wbc->sync_mode != WB_SYNC_NONE)
1451                                 wait_on_page_writeback(page);
1452
1453                         if (PageWriteback(page) ||
1454                                         !clear_page_dirty_for_io(page)) {
1455                                 unlock_page(page);
1456                                 break;
1457                         }
1458
1459                         /*
1460                          * This actually clears the dirty bit in the radix tree.
1461                          * See cifs_writepage() for more commentary.
1462                          */
1463                         set_page_writeback(page);
1464
1465                         if (page_offset(page) >= mapping->host->i_size) {
1466                                 done = 1;
1467                                 unlock_page(page);
1468                                 end_page_writeback(page);
1469                                 break;
1470                         }
1471
1472                         /*
1473                          * BB can we get rid of this?  pages are held by pvec
1474                          */
1475                         page_cache_get(page);
1476
1477                         len = min(mapping->host->i_size - page_offset(page),
1478                                   (loff_t)PAGE_CACHE_SIZE);
1479
1480                         /* reserve iov[0] for the smb header */
1481                         n_iov++;
1482                         iov[n_iov].iov_base = kmap(page);
1483                         iov[n_iov].iov_len = len;
1484                         bytes_to_write += len;
1485
1486                         if (first < 0) {
1487                                 first = i;
1488                                 offset = page_offset(page);
1489                         }
1490                         next = page->index + 1;
1491                         if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1492                                 break;
1493                 }
1494                 if (n_iov) {
1495                         /* Search for a writable handle every time we call
1496                          * CIFSSMBWrite2.  We can't rely on the last handle
1497                          * we used to still be valid
1498                          */
1499                         open_file = find_writable_file(CIFS_I(mapping->host));
1500                         if (!open_file) {
1501                                 cERROR(1, "No writable handles for inode");
1502                                 rc = -EBADF;
1503                         } else {
1504                                 long_op = cifs_write_timeout(cifsi, offset);
1505                                 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1506                                                    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                                 if (rc || bytes_written < bytes_to_write) {
1514                                         cERROR(1, "Write2 ret %d, wrote %d",
1515                                                   rc, bytes_written);
1516                                         /* BB what if continued retry is
1517                                            requested via mount flags? */
1518                                         if (rc == -ENOSPC)
1519                                                 set_bit(AS_ENOSPC, &mapping->flags);
1520                                         else
1521                                                 set_bit(AS_EIO, &mapping->flags);
1522                                 } else {
1523                                         cifs_stats_bytes_written(cifs_sb->tcon,
1524                                                                  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 = CIFS_SB(inode->i_sb)->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         pTcon = cifs_sb->tcon;
1754
1755         if (file->private_data == NULL) {
1756                 rc = -EBADF;
1757                 FreeXid(xid);
1758                 return rc;
1759         }
1760         open_file = file->private_data;
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         pTcon = cifs_sb->tcon;
1835
1836         if (file->private_data == NULL) {
1837                 rc = -EBADF;
1838                 FreeXid(xid);
1839                 return rc;
1840         }
1841         open_file = file->private_data;
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 = cifs_sb->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         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2316         int rc, waitrc = 0;
2317
2318         if (inode && S_ISREG(inode->i_mode)) {
2319                 if (cinode->clientCanCacheRead)
2320                         break_lease(inode, O_RDONLY);
2321                 else
2322                         break_lease(inode, O_WRONLY);
2323                 rc = filemap_fdatawrite(inode->i_mapping);
2324                 if (cinode->clientCanCacheRead == 0) {
2325                         waitrc = filemap_fdatawait(inode->i_mapping);
2326                         invalidate_remote_inode(inode);
2327                 }
2328                 if (!rc)
2329                         rc = waitrc;
2330                 if (rc)
2331                         cinode->write_behind_rc = rc;
2332                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2333         }
2334
2335         /*
2336          * releasing stale oplock after recent reconnect of smb session using
2337          * a now incorrect file handle is not a data integrity issue but do
2338          * not bother sending an oplock release if session to server still is
2339          * disconnected since oplock already released by the server
2340          */
2341         if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2342                 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2343                                  LOCKING_ANDX_OPLOCK_RELEASE, false);
2344                 cFYI(1, "Oplock release rc = %d", rc);
2345         }
2346
2347         /*
2348          * We might have kicked in before is_valid_oplock_break()
2349          * finished grabbing reference for us.  Make sure it's done by
2350          * waiting for GlobalSMSSeslock.
2351          */
2352         write_lock(&GlobalSMBSeslock);
2353         write_unlock(&GlobalSMBSeslock);
2354
2355         cifs_oplock_break_put(cfile);
2356 }
2357
2358 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2359 {
2360         mntget(cfile->mnt);
2361         cifsFileInfo_get(cfile);
2362 }
2363
2364 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2365 {
2366         mntput(cfile->mnt);
2367         cifsFileInfo_put(cfile);
2368 }
2369
2370 const struct address_space_operations cifs_addr_ops = {
2371         .readpage = cifs_readpage,
2372         .readpages = cifs_readpages,
2373         .writepage = cifs_writepage,
2374         .writepages = cifs_writepages,
2375         .write_begin = cifs_write_begin,
2376         .write_end = cifs_write_end,
2377         .set_page_dirty = __set_page_dirty_nobuffers,
2378         .releasepage = cifs_release_page,
2379         .invalidatepage = cifs_invalidate_page,
2380         /* .sync_page = cifs_sync_page, */
2381         /* .direct_IO = */
2382 };
2383
2384 /*
2385  * cifs_readpages requires the server to support a buffer large enough to
2386  * contain the header plus one complete page of data.  Otherwise, we need
2387  * to leave cifs_readpages out of the address space operations.
2388  */
2389 const struct address_space_operations cifs_addr_ops_smallbuf = {
2390         .readpage = cifs_readpage,
2391         .writepage = cifs_writepage,
2392         .writepages = cifs_writepages,
2393         .write_begin = cifs_write_begin,
2394         .write_end = cifs_write_end,
2395         .set_page_dirty = __set_page_dirty_nobuffers,
2396         .releasepage = cifs_release_page,
2397         .invalidatepage = cifs_invalidate_page,
2398         /* .sync_page = cifs_sync_page, */
2399         /* .direct_IO = */
2400 };