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