fs/cifs/file.c

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