fs/cifs/file.c

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