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