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