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 <linux/swap.h>
  36 #include <asm/div64.h>
  37 #include "cifsfs.h"
  38 #include "cifspdu.h"
  39 #include "cifsglob.h"
  40 #include "cifsproto.h"
  41 #include "cifs_unicode.h"
  42 #include "cifs_debug.h"
  43 #include "cifs_fs_sb.h"
  44 #include "fscache.h"
  45
  46 static inline int cifs_convert_flags(unsigned int flags)
  47 {
  48         if ((flags & O_ACCMODE) == O_RDONLY)
  49                 return GENERIC_READ;
  50         else if ((flags & O_ACCMODE) == O_WRONLY)
  51                 return GENERIC_WRITE;
  52         else if ((flags & O_ACCMODE) == O_RDWR) {
  53                 /* GENERIC_ALL is too much permission to request
  54                    can cause unnecessary access denied on create */
  55                 /* return GENERIC_ALL; */
  56                 return (GENERIC_READ | GENERIC_WRITE);
  57         }
  58
  59         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  60                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  61                 FILE_READ_DATA);
  62 }
  63
  64 static u32 cifs_posix_convert_flags(unsigned int flags)
  65 {
  66         u32 posix_flags = 0;
  67
  68         if ((flags & O_ACCMODE) == O_RDONLY)
  69                 posix_flags = SMB_O_RDONLY;
  70         else if ((flags & O_ACCMODE) == O_WRONLY)
  71                 posix_flags = SMB_O_WRONLY;
  72         else if ((flags & O_ACCMODE) == O_RDWR)
  73                 posix_flags = SMB_O_RDWR;
  74
  75         if (flags & O_CREAT)
  76                 posix_flags |= SMB_O_CREAT;
  77         if (flags & O_EXCL)
  78                 posix_flags |= SMB_O_EXCL;
  79         if (flags & O_TRUNC)
  80                 posix_flags |= SMB_O_TRUNC;
  81         /* be safe and imply O_SYNC for O_DSYNC */
  82         if (flags & O_DSYNC)
  83                 posix_flags |= SMB_O_SYNC;
  84         if (flags & O_DIRECTORY)
  85                 posix_flags |= SMB_O_DIRECTORY;
  86         if (flags & O_NOFOLLOW)
  87                 posix_flags |= SMB_O_NOFOLLOW;
  88         if (flags & O_DIRECT)
  89                 posix_flags |= SMB_O_DIRECT;
  90
  91         return posix_flags;
  92 }
  93
  94 static inline int cifs_get_disposition(unsigned int flags)
  95 {
  96         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
  97                 return FILE_CREATE;
  98         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
  99                 return FILE_OVERWRITE_IF;
 100         else if ((flags & O_CREAT) == O_CREAT)
 101                 return FILE_OPEN_IF;
 102         else if ((flags & O_TRUNC) == O_TRUNC)
 103                 return FILE_OVERWRITE;
 104         else
 105                 return FILE_OPEN;
 106 }
 107
 108 int cifs_posix_open(char *full_path, struct inode **pinode,
 109                         struct super_block *sb, int mode, unsigned int f_flags,
 110                         __u32 *poplock, __u16 *pnetfid, int xid)
 111 {
 112         int rc;
 113         FILE_UNIX_BASIC_INFO *presp_data;
 114         __u32 posix_flags = 0;
 115         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 116         struct cifs_fattr fattr;
 117         struct tcon_link *tlink;
 118         struct cifs_tcon *tcon;
 119
 120         cFYI(1, "posix open %s", full_path);
 121
 122         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 123         if (presp_data == NULL)
 124                 return -ENOMEM;
 125
 126         tlink = cifs_sb_tlink(cifs_sb);
 127         if (IS_ERR(tlink)) {
 128                 rc = PTR_ERR(tlink);
 129                 goto posix_open_ret;
 130         }
 131
 132         tcon = tlink_tcon(tlink);
 133         mode &= ~current_umask();
 134
 135         posix_flags = cifs_posix_convert_flags(f_flags);
 136         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 137                              poplock, full_path, cifs_sb->local_nls,
 138                              cifs_sb->mnt_cifs_flags &
 139                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 140         cifs_put_tlink(tlink);
 141
 142         if (rc)
 143                 goto posix_open_ret;
 144
 145         if (presp_data->Type == cpu_to_le32(-1))
 146                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 147
 148         if (!pinode)
 149                 goto posix_open_ret; /* caller does not need info */
 150
 151         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 152
 153         /* get new inode and set it up */
 154         if (*pinode == NULL) {
 155                 cifs_fill_uniqueid(sb, &fattr);
 156                 *pinode = cifs_iget(sb, &fattr);
 157                 if (!*pinode) {
 158                         rc = -ENOMEM;
 159                         goto posix_open_ret;
 160                 }
 161         } else {
 162                 cifs_fattr_to_inode(*pinode, &fattr);
 163         }
 164
 165 posix_open_ret:
 166         kfree(presp_data);
 167         return rc;
 168 }
 169
 170 static int
 171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 172              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
 173              __u16 *pnetfid, int xid)
 174 {
 175         int rc;
 176         int desiredAccess;
 177         int disposition;
 178         int create_options = CREATE_NOT_DIR;
 179         FILE_ALL_INFO *buf;
 180
 181         desiredAccess = cifs_convert_flags(f_flags);
 182
 183 /*********************************************************************
 184  *  open flag mapping table:
 185  *
 186  *      POSIX Flag            CIFS Disposition
 187  *      ----------            ----------------
 188  *      O_CREAT               FILE_OPEN_IF
 189  *      O_CREAT | O_EXCL      FILE_CREATE
 190  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 191  *      O_TRUNC               FILE_OVERWRITE
 192  *      none of the above     FILE_OPEN
 193  *
 194  *      Note that there is not a direct match between disposition
 195  *      FILE_SUPERSEDE (ie create whether or not file exists although
 196  *      O_CREAT | O_TRUNC is similar but truncates the existing
 197  *      file rather than creating a new file as FILE_SUPERSEDE does
 198  *      (which uses the attributes / metadata passed in on open call)
 199  *?
 200  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 201  *?  and the read write flags match reasonably.  O_LARGEFILE
 202  *?  is irrelevant because largefile support is always used
 203  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 204  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 205  *********************************************************************/
 206
 207         disposition = cifs_get_disposition(f_flags);
 208
 209         /* BB pass O_SYNC flag through on file attributes .. BB */
 210
 211         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 212         if (!buf)
 213                 return -ENOMEM;
 214
 215         if (backup_cred(cifs_sb))
 216                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 217
 218         if (tcon->ses->capabilities & CAP_NT_SMBS)
 219                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 220                          desiredAccess, create_options, pnetfid, poplock, buf,
 221                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 222                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
 223         else
 224                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 225                         desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
 226                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 227                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
 228
 229         if (rc)
 230                 goto out;
 231
 232         if (tcon->unix_ext)
 233                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 234                                               xid);
 235         else
 236                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 237                                          xid, pnetfid);
 238
 239 out:
 240         kfree(buf);
 241         return rc;
 242 }
 243
 244 struct cifsFileInfo *
 245 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
 246                   struct tcon_link *tlink, __u32 oplock)
 247 {
 248         struct dentry *dentry = file->f_path.dentry;
 249         struct inode *inode = dentry->d_inode;
 250         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
 251         struct cifsFileInfo *pCifsFile;
 252
 253         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 254         if (pCifsFile == NULL)
 255                 return pCifsFile;
 256
 257         pCifsFile->count = 1;
 258         pCifsFile->netfid = fileHandle;
 259         pCifsFile->pid = current->tgid;
 260         pCifsFile->uid = current_fsuid();
 261         pCifsFile->dentry = dget(dentry);
 262         pCifsFile->f_flags = file->f_flags;
 263         pCifsFile->invalidHandle = false;
 264         pCifsFile->tlink = cifs_get_tlink(tlink);
 265         mutex_init(&pCifsFile->fh_mutex);
 266         INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
 267         INIT_LIST_HEAD(&pCifsFile->llist);
 268
 269         spin_lock(&cifs_file_list_lock);
 270         list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
 271         /* if readable file instance put first in list*/
 272         if (file->f_mode & FMODE_READ)
 273                 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
 274         else
 275                 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
 276         spin_unlock(&cifs_file_list_lock);
 277
 278         cifs_set_oplock_level(pCifsInode, oplock);
 279         pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
 280
 281         file->private_data = pCifsFile;
 282         return pCifsFile;
 283 }
 284
 285 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
 286
 287 /*
 288  * Release a reference on the file private data. This may involve closing
 289  * the filehandle out on the server. Must be called without holding
 290  * cifs_file_list_lock.
 291  */
 292 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 293 {
 294         struct inode *inode = cifs_file->dentry->d_inode;
 295         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 296         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 297         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 298         struct cifsLockInfo *li, *tmp;
 299
 300         spin_lock(&cifs_file_list_lock);
 301         if (--cifs_file->count > 0) {
 302                 spin_unlock(&cifs_file_list_lock);
 303                 return;
 304         }
 305
 306         /* remove it from the lists */
 307         list_del(&cifs_file->flist);
 308         list_del(&cifs_file->tlist);
 309
 310         if (list_empty(&cifsi->openFileList)) {
 311                 cFYI(1, "closing last open instance for inode %p",
 312                         cifs_file->dentry->d_inode);
 313
 314                 /* in strict cache mode we need invalidate mapping on the last
 315                    close  because it may cause a error when we open this file
 316                    again and get at least level II oplock */
 317                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 318                         CIFS_I(inode)->invalid_mapping = true;
 319
 320                 cifs_set_oplock_level(cifsi, 0);
 321         }
 322         spin_unlock(&cifs_file_list_lock);
 323
 324         cancel_work_sync(&cifs_file->oplock_break);
 325
 326         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 327                 int xid, rc;
 328
 329                 xid = GetXid();
 330                 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
 331                 FreeXid(xid);
 332         }
 333
 334         /* Delete any outstanding lock records. We'll lose them when the file
 335          * is closed anyway.
 336          */
 337         mutex_lock(&cifsi->lock_mutex);
 338         list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
 339                 list_del(&li->llist);
 340                 cifs_del_lock_waiters(li);
 341                 kfree(li);
 342         }
 343         mutex_unlock(&cifsi->lock_mutex);
 344
 345         cifs_put_tlink(cifs_file->tlink);
 346         dput(cifs_file->dentry);
 347         kfree(cifs_file);
 348 }
 349
 350 int cifs_open(struct inode *inode, struct file *file)
 351 {
 352         int rc = -EACCES;
 353         int xid;
 354         __u32 oplock;
 355         struct cifs_sb_info *cifs_sb;
 356         struct cifs_tcon *tcon;
 357         struct tcon_link *tlink;
 358         struct cifsFileInfo *pCifsFile = NULL;
 359         char *full_path = NULL;
 360         bool posix_open_ok = false;
 361         __u16 netfid;
 362
 363         xid = GetXid();
 364
 365         cifs_sb = CIFS_SB(inode->i_sb);
 366         tlink = cifs_sb_tlink(cifs_sb);
 367         if (IS_ERR(tlink)) {
 368                 FreeXid(xid);
 369                 return PTR_ERR(tlink);
 370         }
 371         tcon = tlink_tcon(tlink);
 372
 373         full_path = build_path_from_dentry(file->f_path.dentry);
 374         if (full_path == NULL) {
 375                 rc = -ENOMEM;
 376                 goto out;
 377         }
 378
 379         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
 380                  inode, file->f_flags, full_path);
 381
 382         if (tcon->ses->server->oplocks)
 383                 oplock = REQ_OPLOCK;
 384         else
 385                 oplock = 0;
 386
 387         if (!tcon->broken_posix_open && tcon->unix_ext &&
 388             (tcon->ses->capabilities & CAP_UNIX) &&
 389             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 390                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 391                 /* can not refresh inode info since size could be stale */
 392                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 393                                 cifs_sb->mnt_file_mode /* ignored */,
 394                                 file->f_flags, &oplock, &netfid, xid);
 395                 if (rc == 0) {
 396                         cFYI(1, "posix open succeeded");
 397                         posix_open_ok = true;
 398                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 399                         if (tcon->ses->serverNOS)
 400                                 cERROR(1, "server %s of type %s returned"
 401                                            " unexpected error on SMB posix open"
 402                                            ", disabling posix open support."
 403                                            " Check if server update available.",
 404                                            tcon->ses->serverName,
 405                                            tcon->ses->serverNOS);
 406                         tcon->broken_posix_open = true;
 407                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 408                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 409                         goto out;
 410                 /* else fallthrough to retry open the old way on network i/o
 411                    or DFS errors */
 412         }
 413
 414         if (!posix_open_ok) {
 415                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 416                                   file->f_flags, &oplock, &netfid, xid);
 417                 if (rc)
 418                         goto out;
 419         }
 420
 421         pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
 422         if (pCifsFile == NULL) {
 423                 CIFSSMBClose(xid, tcon, netfid);
 424                 rc = -ENOMEM;
 425                 goto out;
 426         }
 427
 428         cifs_fscache_set_inode_cookie(inode, file);
 429
 430         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 431                 /* time to set mode which we can not set earlier due to
 432                    problems creating new read-only files */
 433                 struct cifs_unix_set_info_args args = {
 434                         .mode   = inode->i_mode,
 435                         .uid    = NO_CHANGE_64,
 436                         .gid    = NO_CHANGE_64,
 437                         .ctime  = NO_CHANGE_64,
 438                         .atime  = NO_CHANGE_64,
 439                         .mtime  = NO_CHANGE_64,
 440                         .device = 0,
 441                 };
 442                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
 443                                         pCifsFile->pid);
 444         }
 445
 446 out:
 447         kfree(full_path);
 448         FreeXid(xid);
 449         cifs_put_tlink(tlink);
 450         return rc;
 451 }
 452
 453 /* Try to reacquire byte range locks that were released when session */
 454 /* to server was lost */
 455 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
 456 {
 457         int rc = 0;
 458
 459 /* BB list all locks open on this file and relock */
 460
 461         return rc;
 462 }
 463
 464 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
 465 {
 466         int rc = -EACCES;
 467         int xid;
 468         __u32 oplock;
 469         struct cifs_sb_info *cifs_sb;
 470         struct cifs_tcon *tcon;
 471         struct cifsInodeInfo *pCifsInode;
 472         struct inode *inode;
 473         char *full_path = NULL;
 474         int desiredAccess;
 475         int disposition = FILE_OPEN;
 476         int create_options = CREATE_NOT_DIR;
 477         __u16 netfid;
 478
 479         xid = GetXid();
 480         mutex_lock(&pCifsFile->fh_mutex);
 481         if (!pCifsFile->invalidHandle) {
 482                 mutex_unlock(&pCifsFile->fh_mutex);
 483                 rc = 0;
 484                 FreeXid(xid);
 485                 return rc;
 486         }
 487
 488         inode = pCifsFile->dentry->d_inode;
 489         cifs_sb = CIFS_SB(inode->i_sb);
 490         tcon = tlink_tcon(pCifsFile->tlink);
 491
 492 /* can not grab rename sem here because various ops, including
 493    those that already have the rename sem can end up causing writepage
 494    to get called and if the server was down that means we end up here,
 495    and we can never tell if the caller already has the rename_sem */
 496         full_path = build_path_from_dentry(pCifsFile->dentry);
 497         if (full_path == NULL) {
 498                 rc = -ENOMEM;
 499                 mutex_unlock(&pCifsFile->fh_mutex);
 500                 FreeXid(xid);
 501                 return rc;
 502         }
 503
 504         cFYI(1, "inode = 0x%p file flags 0x%x for %s",
 505                  inode, pCifsFile->f_flags, full_path);
 506
 507         if (tcon->ses->server->oplocks)
 508                 oplock = REQ_OPLOCK;
 509         else
 510                 oplock = 0;
 511
 512         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 513             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 514                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 515
 516                 /*
 517                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 518                  * original open. Must mask them off for a reopen.
 519                  */
 520                 unsigned int oflags = pCifsFile->f_flags &
 521                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 522
 523                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 524                                 cifs_sb->mnt_file_mode /* ignored */,
 525                                 oflags, &oplock, &netfid, xid);
 526                 if (rc == 0) {
 527                         cFYI(1, "posix reopen succeeded");
 528                         goto reopen_success;
 529                 }
 530                 /* fallthrough to retry open the old way on errors, especially
 531                    in the reconnect path it is important to retry hard */
 532         }
 533
 534         desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
 535
 536         if (backup_cred(cifs_sb))
 537                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 538
 539         /* Can not refresh inode by passing in file_info buf to be returned
 540            by SMBOpen and then calling get_inode_info with returned buf
 541            since file might have write behind data that needs to be flushed
 542            and server version of file size can be stale. If we knew for sure
 543            that inode was not dirty locally we could do this */
 544
 545         rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
 546                          create_options, &netfid, &oplock, NULL,
 547                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 548                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 549         if (rc) {
 550                 mutex_unlock(&pCifsFile->fh_mutex);
 551                 cFYI(1, "cifs_open returned 0x%x", rc);
 552                 cFYI(1, "oplock: %d", oplock);
 553                 goto reopen_error_exit;
 554         }
 555
 556 reopen_success:
 557         pCifsFile->netfid = netfid;
 558         pCifsFile->invalidHandle = false;
 559         mutex_unlock(&pCifsFile->fh_mutex);
 560         pCifsInode = CIFS_I(inode);
 561
 562         if (can_flush) {
 563                 rc = filemap_write_and_wait(inode->i_mapping);
 564                 mapping_set_error(inode->i_mapping, rc);
 565
 566                 if (tcon->unix_ext)
 567                         rc = cifs_get_inode_info_unix(&inode,
 568                                 full_path, inode->i_sb, xid);
 569                 else
 570                         rc = cifs_get_inode_info(&inode,
 571                                 full_path, NULL, inode->i_sb,
 572                                 xid, NULL);
 573         } /* else we are writing out data to server already
 574              and could deadlock if we tried to flush data, and
 575              since we do not know if we have data that would
 576              invalidate the current end of file on the server
 577              we can not go to the server to get the new inod
 578              info */
 579
 580         cifs_set_oplock_level(pCifsInode, oplock);
 581
 582         cifs_relock_file(pCifsFile);
 583
 584 reopen_error_exit:
 585         kfree(full_path);
 586         FreeXid(xid);
 587         return rc;
 588 }
 589
 590 int cifs_close(struct inode *inode, struct file *file)
 591 {
 592         if (file->private_data != NULL) {
 593                 cifsFileInfo_put(file->private_data);
 594                 file->private_data = NULL;
 595         }
 596
 597         /* return code from the ->release op is always ignored */
 598         return 0;
 599 }
 600
 601 int cifs_closedir(struct inode *inode, struct file *file)
 602 {
 603         int rc = 0;
 604         int xid;
 605         struct cifsFileInfo *pCFileStruct = file->private_data;
 606         char *ptmp;
 607
 608         cFYI(1, "Closedir inode = 0x%p", inode);
 609
 610         xid = GetXid();
 611
 612         if (pCFileStruct) {
 613                 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
 614
 615                 cFYI(1, "Freeing private data in close dir");
 616                 spin_lock(&cifs_file_list_lock);
 617                 if (!pCFileStruct->srch_inf.endOfSearch &&
 618                     !pCFileStruct->invalidHandle) {
 619                         pCFileStruct->invalidHandle = true;
 620                         spin_unlock(&cifs_file_list_lock);
 621                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 622                         cFYI(1, "Closing uncompleted readdir with rc %d",
 623                                  rc);
 624                         /* not much we can do if it fails anyway, ignore rc */
 625                         rc = 0;
 626                 } else
 627                         spin_unlock(&cifs_file_list_lock);
 628                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 629                 if (ptmp) {
 630                         cFYI(1, "closedir free smb buf in srch struct");
 631                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 632                         if (pCFileStruct->srch_inf.smallBuf)
 633                                 cifs_small_buf_release(ptmp);
 634                         else
 635                                 cifs_buf_release(ptmp);
 636                 }
 637                 cifs_put_tlink(pCFileStruct->tlink);
 638                 kfree(file->private_data);
 639                 file->private_data = NULL;
 640         }
 641         /* BB can we lock the filestruct while this is going on? */
 642         FreeXid(xid);
 643         return rc;
 644 }
 645
 646 static struct cifsLockInfo *
 647 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
 648 {
 649         struct cifsLockInfo *lock =
 650                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 651         if (!lock)
 652                 return lock;
 653         lock->offset = offset;
 654         lock->length = length;
 655         lock->type = type;
 656         lock->pid = current->tgid;
 657         INIT_LIST_HEAD(&lock->blist);
 658         init_waitqueue_head(&lock->block_q);
 659         return lock;
 660 }
 661
 662 static void
 663 cifs_del_lock_waiters(struct cifsLockInfo *lock)
 664 {
 665         struct cifsLockInfo *li, *tmp;
 666         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
 667                 list_del_init(&li->blist);
 668                 wake_up(&li->block_q);
 669         }
 670 }
 671
 672 static bool
 673 cifs_find_fid_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
 674                             __u64 length, __u8 type, __u16 netfid,
 675                             struct cifsLockInfo **conf_lock)
 676 {
 677         struct cifsLockInfo *li;
 678
 679         list_for_each_entry(li, &cfile->llist, llist) {
 680                 if (offset + length <= li->offset ||
 681                     offset >= li->offset + li->length)
 682                         continue;
 683                 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
 684                          ((netfid == cfile->netfid && current->tgid == li->pid)
 685                          || type == li->type))
 686                         continue;
 687                 else {
 688                         *conf_lock = li;
 689                         return true;
 690                 }
 691         }
 692         return false;
 693 }
 694
 695 static bool
 696 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
 697                         __u64 length, __u8 type, __u16 netfid,
 698                         struct cifsLockInfo **conf_lock)
 699 {
 700         bool rc = false;
 701         struct cifsFileInfo *fid, *tmp;
 702
 703         spin_lock(&cifs_file_list_lock);
 704         list_for_each_entry_safe(fid, tmp, &cinode->openFileList, flist) {
 705                 rc = cifs_find_fid_lock_conflict(fid, offset, length, type,
 706                                                  netfid, conf_lock);
 707                 if (rc)
 708                         break;
 709         }
 710         spin_unlock(&cifs_file_list_lock);
 711
 712         return rc;
 713 }
 714
 715 /*
 716  * Check if there is another lock that prevents us to set the lock (mandatory
 717  * style). If such a lock exists, update the flock structure with its
 718  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 719  * or leave it the same if we can't. Returns 0 if we don't need to request to
 720  * the server or 1 otherwise.
 721  */
 722 static int
 723 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 724                __u8 type, struct file_lock *flock)
 725 {
 726         int rc = 0;
 727         struct cifsLockInfo *conf_lock;
 728         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 729         bool exist;
 730
 731         mutex_lock(&cinode->lock_mutex);
 732
 733         exist = cifs_find_lock_conflict(cinode, offset, length, type,
 734                                         cfile->netfid, &conf_lock);
 735         if (exist) {
 736                 flock->fl_start = conf_lock->offset;
 737                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
 738                 flock->fl_pid = conf_lock->pid;
 739                 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
 740                         flock->fl_type = F_RDLCK;
 741                 else
 742                         flock->fl_type = F_WRLCK;
 743         } else if (!cinode->can_cache_brlcks)
 744                 rc = 1;
 745         else
 746                 flock->fl_type = F_UNLCK;
 747
 748         mutex_unlock(&cinode->lock_mutex);
 749         return rc;
 750 }
 751
 752 static void
 753 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
 754 {
 755         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 756         mutex_lock(&cinode->lock_mutex);
 757         list_add_tail(&lock->llist, &cfile->llist);
 758         mutex_unlock(&cinode->lock_mutex);
 759 }
 760
 761 /*
 762  * Set the byte-range lock (mandatory style). Returns:
 763  * 1) 0, if we set the lock and don't need to request to the server;
 764  * 2) 1, if no locks prevent us but we need to request to the server;
 765  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
 766  */
 767 static int
 768 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
 769                  bool wait)
 770 {
 771         struct cifsLockInfo *conf_lock;
 772         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 773         bool exist;
 774         int rc = 0;
 775
 776 try_again:
 777         exist = false;
 778         mutex_lock(&cinode->lock_mutex);
 779
 780         exist = cifs_find_lock_conflict(cinode, lock->offset, lock->length,
 781                                         lock->type, cfile->netfid, &conf_lock);
 782         if (!exist && cinode->can_cache_brlcks) {
 783                 list_add_tail(&lock->llist, &cfile->llist);
 784                 mutex_unlock(&cinode->lock_mutex);
 785                 return rc;
 786         }
 787
 788         if (!exist)
 789                 rc = 1;
 790         else if (!wait)
 791                 rc = -EACCES;
 792         else {
 793                 list_add_tail(&lock->blist, &conf_lock->blist);
 794                 mutex_unlock(&cinode->lock_mutex);
 795                 rc = wait_event_interruptible(lock->block_q,
 796                                         (lock->blist.prev == &lock->blist) &&
 797                                         (lock->blist.next == &lock->blist));
 798                 if (!rc)
 799                         goto try_again;
 800                 mutex_lock(&cinode->lock_mutex);
 801                 list_del_init(&lock->blist);
 802         }
 803
 804         mutex_unlock(&cinode->lock_mutex);
 805         return rc;
 806 }
 807
 808 /*
 809  * Check if there is another lock that prevents us to set the lock (posix
 810  * style). If such a lock exists, update the flock structure with its
 811  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 812  * or leave it the same if we can't. Returns 0 if we don't need to request to
 813  * the server or 1 otherwise.
 814  */
 815 static int
 816 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 817 {
 818         int rc = 0;
 819         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 820         unsigned char saved_type = flock->fl_type;
 821
 822         if ((flock->fl_flags & FL_POSIX) == 0)
 823                 return 1;
 824
 825         mutex_lock(&cinode->lock_mutex);
 826         posix_test_lock(file, flock);
 827
 828         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
 829                 flock->fl_type = saved_type;
 830                 rc = 1;
 831         }
 832
 833         mutex_unlock(&cinode->lock_mutex);
 834         return rc;
 835 }
 836
 837 /*
 838  * Set the byte-range lock (posix style). Returns:
 839  * 1) 0, if we set the lock and don't need to request to the server;
 840  * 2) 1, if we need to request to the server;
 841  * 3) <0, if the error occurs while setting the lock.
 842  */
 843 static int
 844 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
 845 {
 846         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 847         int rc = 1;
 848
 849         if ((flock->fl_flags & FL_POSIX) == 0)
 850                 return rc;
 851
 852 try_again:
 853         mutex_lock(&cinode->lock_mutex);
 854         if (!cinode->can_cache_brlcks) {
 855                 mutex_unlock(&cinode->lock_mutex);
 856                 return rc;
 857         }
 858
 859         rc = posix_lock_file(file, flock, NULL);
 860         mutex_unlock(&cinode->lock_mutex);
 861         if (rc == FILE_LOCK_DEFERRED) {
 862                 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
 863                 if (!rc)
 864                         goto try_again;
 865                 locks_delete_block(flock);
 866         }
 867         return rc;
 868 }
 869
 870 static int
 871 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
 872 {
 873         int xid, rc = 0, stored_rc;
 874         struct cifsLockInfo *li, *tmp;
 875         struct cifs_tcon *tcon;
 876         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 877         unsigned int num, max_num;
 878         LOCKING_ANDX_RANGE *buf, *cur;
 879         int types[] = {LOCKING_ANDX_LARGE_FILES,
 880                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
 881         int i;
 882
 883         xid = GetXid();
 884         tcon = tlink_tcon(cfile->tlink);
 885
 886         mutex_lock(&cinode->lock_mutex);
 887         if (!cinode->can_cache_brlcks) {
 888                 mutex_unlock(&cinode->lock_mutex);
 889                 FreeXid(xid);
 890                 return rc;
 891         }
 892
 893         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
 894                   sizeof(LOCKING_ANDX_RANGE);
 895         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
 896         if (!buf) {
 897                 mutex_unlock(&cinode->lock_mutex);
 898                 FreeXid(xid);
 899                 return rc;
 900         }
 901
 902         for (i = 0; i < 2; i++) {
 903                 cur = buf;
 904                 num = 0;
 905                 list_for_each_entry_safe(li, tmp, &cfile->llist, llist) {
 906                         if (li->type != types[i])
 907                                 continue;
 908                         cur->Pid = cpu_to_le16(li->pid);
 909                         cur->LengthLow = cpu_to_le32((u32)li->length);
 910                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
 911                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
 912                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
 913                         if (++num == max_num) {
 914                                 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 915                                                        li->type, 0, num, buf);
 916                                 if (stored_rc)
 917                                         rc = stored_rc;
 918                                 cur = buf;
 919                                 num = 0;
 920                         } else
 921                                 cur++;
 922                 }
 923
 924                 if (num) {
 925                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 926                                                types[i], 0, num, buf);
 927                         if (stored_rc)
 928                                 rc = stored_rc;
 929                 }
 930         }
 931
 932         cinode->can_cache_brlcks = false;
 933         mutex_unlock(&cinode->lock_mutex);
 934
 935         kfree(buf);
 936         FreeXid(xid);
 937         return rc;
 938 }
 939
 940 /* copied from fs/locks.c with a name change */
 941 #define cifs_for_each_lock(inode, lockp) \
 942         for (lockp = &inode->i_flock; *lockp != NULL; \
 943              lockp = &(*lockp)->fl_next)
 944
 945 struct lock_to_push {
 946         struct list_head llist;
 947         __u64 offset;
 948         __u64 length;
 949         __u32 pid;
 950         __u16 netfid;
 951         __u8 type;
 952 };
 953
 954 static int
 955 cifs_push_posix_locks(struct cifsFileInfo *cfile)
 956 {
 957         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 958         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 959         struct file_lock *flock, **before;
 960         unsigned int count = 0, i = 0;
 961         int rc = 0, xid, type;
 962         struct list_head locks_to_send, *el;
 963         struct lock_to_push *lck, *tmp;
 964         __u64 length;
 965
 966         xid = GetXid();
 967
 968         mutex_lock(&cinode->lock_mutex);
 969         if (!cinode->can_cache_brlcks) {
 970                 mutex_unlock(&cinode->lock_mutex);
 971                 FreeXid(xid);
 972                 return rc;
 973         }
 974
 975         lock_flocks();
 976         cifs_for_each_lock(cfile->dentry->d_inode, before) {
 977                 if ((*before)->fl_flags & FL_POSIX)
 978                         count++;
 979         }
 980         unlock_flocks();
 981
 982         INIT_LIST_HEAD(&locks_to_send);
 983
 984         /*
 985          * Allocating count locks is enough because no FL_POSIX locks can be
 986          * added to the list while we are holding cinode->lock_mutex that
 987          * protects locking operations of this inode.
 988          */
 989         for (; i < count; i++) {
 990                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
 991                 if (!lck) {
 992                         rc = -ENOMEM;
 993                         goto err_out;
 994                 }
 995                 list_add_tail(&lck->llist, &locks_to_send);
 996         }
 997
 998         el = locks_to_send.next;
 999         lock_flocks();
1000         cifs_for_each_lock(cfile->dentry->d_inode, before) {
1001                 flock = *before;
1002                 if ((flock->fl_flags & FL_POSIX) == 0)
1003                         continue;
1004                 if (el == &locks_to_send) {
1005                         /*
1006                          * The list ended. We don't have enough allocated
1007                          * structures - something is really wrong.
1008                          */
1009                         cERROR(1, "Can't push all brlocks!");
1010                         break;
1011                 }
1012                 length = 1 + flock->fl_end - flock->fl_start;
1013                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1014                         type = CIFS_RDLCK;
1015                 else
1016                         type = CIFS_WRLCK;
1017                 lck = list_entry(el, struct lock_to_push, llist);
1018                 lck->pid = flock->fl_pid;
1019                 lck->netfid = cfile->netfid;
1020                 lck->length = length;
1021                 lck->type = type;
1022                 lck->offset = flock->fl_start;
1023                 el = el->next;
1024         }
1025         unlock_flocks();
1026
1027         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1028                 struct file_lock tmp_lock;
1029                 int stored_rc;
1030
1031                 tmp_lock.fl_start = lck->offset;
1032                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1033                                              0, lck->length, &tmp_lock,
1034                                              lck->type, 0);
1035                 if (stored_rc)
1036                         rc = stored_rc;
1037                 list_del(&lck->llist);
1038                 kfree(lck);
1039         }
1040
1041 out:
1042         cinode->can_cache_brlcks = false;
1043         mutex_unlock(&cinode->lock_mutex);
1044
1045         FreeXid(xid);
1046         return rc;
1047 err_out:
1048         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1049                 list_del(&lck->llist);
1050                 kfree(lck);
1051         }
1052         goto out;
1053 }
1054
1055 static int
1056 cifs_push_locks(struct cifsFileInfo *cfile)
1057 {
1058         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1059         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1060
1061         if ((tcon->ses->capabilities & CAP_UNIX) &&
1062             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1063             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1064                 return cifs_push_posix_locks(cfile);
1065
1066         return cifs_push_mandatory_locks(cfile);
1067 }
1068
1069 static void
1070 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1071                 bool *wait_flag)
1072 {
1073         if (flock->fl_flags & FL_POSIX)
1074                 cFYI(1, "Posix");
1075         if (flock->fl_flags & FL_FLOCK)
1076                 cFYI(1, "Flock");
1077         if (flock->fl_flags & FL_SLEEP) {
1078                 cFYI(1, "Blocking lock");
1079                 *wait_flag = true;
1080         }
1081         if (flock->fl_flags & FL_ACCESS)
1082                 cFYI(1, "Process suspended by mandatory locking - "
1083                         "not implemented yet");
1084         if (flock->fl_flags & FL_LEASE)
1085                 cFYI(1, "Lease on file - not implemented yet");
1086         if (flock->fl_flags &
1087             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1088                 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1089
1090         *type = LOCKING_ANDX_LARGE_FILES;
1091         if (flock->fl_type == F_WRLCK) {
1092                 cFYI(1, "F_WRLCK ");
1093                 *lock = 1;
1094         } else if (flock->fl_type == F_UNLCK) {
1095                 cFYI(1, "F_UNLCK");
1096                 *unlock = 1;
1097                 /* Check if unlock includes more than one lock range */
1098         } else if (flock->fl_type == F_RDLCK) {
1099                 cFYI(1, "F_RDLCK");
1100                 *type |= LOCKING_ANDX_SHARED_LOCK;
1101                 *lock = 1;
1102         } else if (flock->fl_type == F_EXLCK) {
1103                 cFYI(1, "F_EXLCK");
1104                 *lock = 1;
1105         } else if (flock->fl_type == F_SHLCK) {
1106                 cFYI(1, "F_SHLCK");
1107                 *type |= LOCKING_ANDX_SHARED_LOCK;
1108                 *lock = 1;
1109         } else
1110                 cFYI(1, "Unknown type of lock");
1111 }
1112
1113 static int
1114 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1115            bool wait_flag, bool posix_lck, int xid)
1116 {
1117         int rc = 0;
1118         __u64 length = 1 + flock->fl_end - flock->fl_start;
1119         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1120         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1121         __u16 netfid = cfile->netfid;
1122
1123         if (posix_lck) {
1124                 int posix_lock_type;
1125
1126                 rc = cifs_posix_lock_test(file, flock);
1127                 if (!rc)
1128                         return rc;
1129
1130                 if (type & LOCKING_ANDX_SHARED_LOCK)
1131                         posix_lock_type = CIFS_RDLCK;
1132                 else
1133                         posix_lock_type = CIFS_WRLCK;
1134                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1135                                       1 /* get */, length, flock,
1136                                       posix_lock_type, wait_flag);
1137                 return rc;
1138         }
1139
1140         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1141         if (!rc)
1142                 return rc;
1143
1144         /* BB we could chain these into one lock request BB */
1145         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1146                          flock->fl_start, 0, 1, type, 0, 0);
1147         if (rc == 0) {
1148                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1149                                  length, flock->fl_start, 1, 0,
1150                                  type, 0, 0);
1151                 flock->fl_type = F_UNLCK;
1152                 if (rc != 0)
1153                         cERROR(1, "Error unlocking previously locked "
1154                                    "range %d during test of lock", rc);
1155                 return 0;
1156         }
1157
1158         if (type & LOCKING_ANDX_SHARED_LOCK) {
1159                 flock->fl_type = F_WRLCK;
1160                 return 0;
1161         }
1162
1163         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1164                          flock->fl_start, 0, 1,
1165                          type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1166         if (rc == 0) {
1167                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1168                                  length, flock->fl_start, 1, 0,
1169                                  type | LOCKING_ANDX_SHARED_LOCK,
1170                                  0, 0);
1171                 flock->fl_type = F_RDLCK;
1172                 if (rc != 0)
1173                         cERROR(1, "Error unlocking previously locked "
1174                                   "range %d during test of lock", rc);
1175         } else
1176                 flock->fl_type = F_WRLCK;
1177
1178         return 0;
1179 }
1180
1181 static void
1182 cifs_move_llist(struct list_head *source, struct list_head *dest)
1183 {
1184         struct list_head *li, *tmp;
1185         list_for_each_safe(li, tmp, source)
1186                 list_move(li, dest);
1187 }
1188
1189 static void
1190 cifs_free_llist(struct list_head *llist)
1191 {
1192         struct cifsLockInfo *li, *tmp;
1193         list_for_each_entry_safe(li, tmp, llist, llist) {
1194                 cifs_del_lock_waiters(li);
1195                 list_del(&li->llist);
1196                 kfree(li);
1197         }
1198 }
1199
1200 static int
1201 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1202 {
1203         int rc = 0, stored_rc;
1204         int types[] = {LOCKING_ANDX_LARGE_FILES,
1205                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1206         unsigned int i;
1207         unsigned int max_num, num;
1208         LOCKING_ANDX_RANGE *buf, *cur;
1209         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1210         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1211         struct cifsLockInfo *li, *tmp;
1212         __u64 length = 1 + flock->fl_end - flock->fl_start;
1213         struct list_head tmp_llist;
1214
1215         INIT_LIST_HEAD(&tmp_llist);
1216
1217         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1218                   sizeof(LOCKING_ANDX_RANGE);
1219         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1220         if (!buf)
1221                 return -ENOMEM;
1222
1223         mutex_lock(&cinode->lock_mutex);
1224         for (i = 0; i < 2; i++) {
1225                 cur = buf;
1226                 num = 0;
1227                 list_for_each_entry_safe(li, tmp, &cfile->llist, llist) {
1228                         if (flock->fl_start > li->offset ||
1229                             (flock->fl_start + length) <
1230                             (li->offset + li->length))
1231                                 continue;
1232                         if (current->tgid != li->pid)
1233                                 continue;
1234                         if (types[i] != li->type)
1235                                 continue;
1236                         if (!cinode->can_cache_brlcks) {
1237                                 cur->Pid = cpu_to_le16(li->pid);
1238                                 cur->LengthLow = cpu_to_le32((u32)li->length);
1239                                 cur->LengthHigh =
1240                                         cpu_to_le32((u32)(li->length>>32));
1241                                 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1242                                 cur->OffsetHigh =
1243                                         cpu_to_le32((u32)(li->offset>>32));
1244                                 /*
1245                                  * We need to save a lock here to let us add
1246                                  * it again to the file's list if the unlock
1247                                  * range request fails on the server.
1248                                  */
1249                                 list_move(&li->llist, &tmp_llist);
1250                                 if (++num == max_num) {
1251                                         stored_rc = cifs_lockv(xid, tcon,
1252                                                                cfile->netfid,
1253                                                                li->type, num,
1254                                                                0, buf);
1255                                         if (stored_rc) {
1256                                                 /*
1257                                                  * We failed on the unlock range
1258                                                  * request - add all locks from
1259                                                  * the tmp list to the head of
1260                                                  * the file's list.
1261                                                  */
1262                                                 cifs_move_llist(&tmp_llist,
1263                                                                 &cfile->llist);
1264                                                 rc = stored_rc;
1265                                         } else
1266                                                 /*
1267                                                  * The unlock range request
1268                                                  * succeed - free the tmp list.
1269                                                  */
1270                                                 cifs_free_llist(&tmp_llist);
1271                                         cur = buf;
1272                                         num = 0;
1273                                 } else
1274                                         cur++;
1275                         } else {
1276                                 /*
1277                                  * We can cache brlock requests - simply remove
1278                                  * a lock from the file's list.
1279                                  */
1280                                 list_del(&li->llist);
1281                                 cifs_del_lock_waiters(li);
1282                                 kfree(li);
1283                         }
1284                 }
1285                 if (num) {
1286                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1287                                                types[i], num, 0, buf);
1288                         if (stored_rc) {
1289                                 cifs_move_llist(&tmp_llist, &cfile->llist);
1290                                 rc = stored_rc;
1291                         } else
1292                                 cifs_free_llist(&tmp_llist);
1293                 }
1294         }
1295
1296         mutex_unlock(&cinode->lock_mutex);
1297         kfree(buf);
1298         return rc;
1299 }
1300
1301 static int
1302 cifs_setlk(struct file *file,  struct file_lock *flock, __u8 type,
1303            bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1304 {
1305         int rc = 0;
1306         __u64 length = 1 + flock->fl_end - flock->fl_start;
1307         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1308         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1309         __u16 netfid = cfile->netfid;
1310
1311         if (posix_lck) {
1312                 int posix_lock_type;
1313
1314                 rc = cifs_posix_lock_set(file, flock);
1315                 if (!rc || rc < 0)
1316                         return rc;
1317
1318                 if (type & LOCKING_ANDX_SHARED_LOCK)
1319                         posix_lock_type = CIFS_RDLCK;
1320                 else
1321                         posix_lock_type = CIFS_WRLCK;
1322
1323                 if (unlock == 1)
1324                         posix_lock_type = CIFS_UNLCK;
1325
1326                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1327                                       0 /* set */, length, flock,
1328                                       posix_lock_type, wait_flag);
1329                 goto out;
1330         }
1331
1332         if (lock) {
1333                 struct cifsLockInfo *lock;
1334
1335                 lock = cifs_lock_init(flock->fl_start, length, type);
1336                 if (!lock)
1337                         return -ENOMEM;
1338
1339                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1340                 if (rc < 0)
1341                         kfree(lock);
1342                 if (rc <= 0)
1343                         goto out;
1344
1345                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1346                                  flock->fl_start, 0, 1, type, wait_flag, 0);
1347                 if (rc) {
1348                         kfree(lock);
1349                         goto out;
1350                 }
1351
1352                 cifs_lock_add(cfile, lock);
1353         } else if (unlock)
1354                 rc = cifs_unlock_range(cfile, flock, xid);
1355
1356 out:
1357         if (flock->fl_flags & FL_POSIX)
1358                 posix_lock_file_wait(file, flock);
1359         return rc;
1360 }
1361
1362 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1363 {
1364         int rc, xid;
1365         int lock = 0, unlock = 0;
1366         bool wait_flag = false;
1367         bool posix_lck = false;
1368         struct cifs_sb_info *cifs_sb;
1369         struct cifs_tcon *tcon;
1370         struct cifsInodeInfo *cinode;
1371         struct cifsFileInfo *cfile;
1372         __u16 netfid;
1373         __u8 type;
1374
1375         rc = -EACCES;
1376         xid = GetXid();
1377
1378         cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1379                 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1380                 flock->fl_start, flock->fl_end);
1381
1382         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1383
1384         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1385         cfile = (struct cifsFileInfo *)file->private_data;
1386         tcon = tlink_tcon(cfile->tlink);
1387         netfid = cfile->netfid;
1388         cinode = CIFS_I(file->f_path.dentry->d_inode);
1389
1390         if ((tcon->ses->capabilities & CAP_UNIX) &&
1391             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1392             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1393                 posix_lck = true;
1394         /*
1395          * BB add code here to normalize offset and length to account for
1396          * negative length which we can not accept over the wire.
1397          */
1398         if (IS_GETLK(cmd)) {
1399                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1400                 FreeXid(xid);
1401                 return rc;
1402         }
1403
1404         if (!lock && !unlock) {
1405                 /*
1406                  * if no lock or unlock then nothing to do since we do not
1407                  * know what it is
1408                  */
1409                 FreeXid(xid);
1410                 return -EOPNOTSUPP;
1411         }
1412
1413         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1414                         xid);
1415         FreeXid(xid);
1416         return rc;
1417 }
1418
1419 /*
1420  * update the file size (if needed) after a write. Should be called with
1421  * the inode->i_lock held
1422  */
1423 void
1424 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1425                       unsigned int bytes_written)
1426 {
1427         loff_t end_of_write = offset + bytes_written;
1428
1429         if (end_of_write > cifsi->server_eof)
1430                 cifsi->server_eof = end_of_write;
1431 }
1432
1433 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1434                           const char *write_data, size_t write_size,
1435                           loff_t *poffset)
1436 {
1437         int rc = 0;
1438         unsigned int bytes_written = 0;
1439         unsigned int total_written;
1440         struct cifs_sb_info *cifs_sb;
1441         struct cifs_tcon *pTcon;
1442         int xid;
1443         struct dentry *dentry = open_file->dentry;
1444         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1445         struct cifs_io_parms io_parms;
1446
1447         cifs_sb = CIFS_SB(dentry->d_sb);
1448
1449         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1450            *poffset, dentry->d_name.name);
1451
1452         pTcon = tlink_tcon(open_file->tlink);
1453
1454         xid = GetXid();
1455
1456         for (total_written = 0; write_size > total_written;
1457              total_written += bytes_written) {
1458                 rc = -EAGAIN;
1459                 while (rc == -EAGAIN) {
1460                         struct kvec iov[2];
1461                         unsigned int len;
1462
1463                         if (open_file->invalidHandle) {
1464                                 /* we could deadlock if we called
1465                                    filemap_fdatawait from here so tell
1466                                    reopen_file not to flush data to
1467                                    server now */
1468                                 rc = cifs_reopen_file(open_file, false);
1469                                 if (rc != 0)
1470                                         break;
1471                         }
1472
1473                         len = min((size_t)cifs_sb->wsize,
1474                                   write_size - total_written);
1475                         /* iov[0] is reserved for smb header */
1476                         iov[1].iov_base = (char *)write_data + total_written;
1477                         iov[1].iov_len = len;
1478                         io_parms.netfid = open_file->netfid;
1479                         io_parms.pid = pid;
1480                         io_parms.tcon = pTcon;
1481                         io_parms.offset = *poffset;
1482                         io_parms.length = len;
1483                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1484                                            1, 0);
1485                 }
1486                 if (rc || (bytes_written == 0)) {
1487                         if (total_written)
1488                                 break;
1489                         else {
1490                                 FreeXid(xid);
1491                                 return rc;
1492                         }
1493                 } else {
1494                         spin_lock(&dentry->d_inode->i_lock);
1495                         cifs_update_eof(cifsi, *poffset, bytes_written);
1496                         spin_unlock(&dentry->d_inode->i_lock);
1497                         *poffset += bytes_written;
1498                 }
1499         }
1500
1501         cifs_stats_bytes_written(pTcon, total_written);
1502
1503         if (total_written > 0) {
1504                 spin_lock(&dentry->d_inode->i_lock);
1505                 if (*poffset > dentry->d_inode->i_size)
1506                         i_size_write(dentry->d_inode, *poffset);
1507                 spin_unlock(&dentry->d_inode->i_lock);
1508         }
1509         mark_inode_dirty_sync(dentry->d_inode);
1510         FreeXid(xid);
1511         return total_written;
1512 }
1513
1514 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1515                                         bool fsuid_only)
1516 {
1517         struct cifsFileInfo *open_file = NULL;
1518         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1519
1520         /* only filter by fsuid on multiuser mounts */
1521         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1522                 fsuid_only = false;
1523
1524         spin_lock(&cifs_file_list_lock);
1525         /* we could simply get the first_list_entry since write-only entries
1526            are always at the end of the list but since the first entry might
1527            have a close pending, we go through the whole list */
1528         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1529                 if (fsuid_only && open_file->uid != current_fsuid())
1530                         continue;
1531                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1532                         if (!open_file->invalidHandle) {
1533                                 /* found a good file */
1534                                 /* lock it so it will not be closed on us */
1535                                 cifsFileInfo_get(open_file);
1536                                 spin_unlock(&cifs_file_list_lock);
1537                                 return open_file;
1538                         } /* else might as well continue, and look for
1539                              another, or simply have the caller reopen it
1540                              again rather than trying to fix this handle */
1541                 } else /* write only file */
1542                         break; /* write only files are last so must be done */
1543         }
1544         spin_unlock(&cifs_file_list_lock);
1545         return NULL;
1546 }
1547
1548 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1549                                         bool fsuid_only)
1550 {
1551         struct cifsFileInfo *open_file;
1552         struct cifs_sb_info *cifs_sb;
1553         bool any_available = false;
1554         int rc;
1555
1556         /* Having a null inode here (because mapping->host was set to zero by
1557         the VFS or MM) should not happen but we had reports of on oops (due to
1558         it being zero) during stress testcases so we need to check for it */
1559
1560         if (cifs_inode == NULL) {
1561                 cERROR(1, "Null inode passed to cifs_writeable_file");
1562                 dump_stack();
1563                 return NULL;
1564         }
1565
1566         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1567
1568         /* only filter by fsuid on multiuser mounts */
1569         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1570                 fsuid_only = false;
1571
1572         spin_lock(&cifs_file_list_lock);
1573 refind_writable:
1574         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1575                 if (!any_available && open_file->pid != current->tgid)
1576                         continue;
1577                 if (fsuid_only && open_file->uid != current_fsuid())
1578                         continue;
1579                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1580                         cifsFileInfo_get(open_file);
1581
1582                         if (!open_file->invalidHandle) {
1583                                 /* found a good writable file */
1584                                 spin_unlock(&cifs_file_list_lock);
1585                                 return open_file;
1586                         }
1587
1588                         spin_unlock(&cifs_file_list_lock);
1589
1590                         /* Had to unlock since following call can block */
1591                         rc = cifs_reopen_file(open_file, false);
1592                         if (!rc)
1593                                 return open_file;
1594
1595                         /* if it fails, try another handle if possible */
1596                         cFYI(1, "wp failed on reopen file");
1597                         cifsFileInfo_put(open_file);
1598
1599                         spin_lock(&cifs_file_list_lock);
1600
1601                         /* else we simply continue to the next entry. Thus
1602                            we do not loop on reopen errors.  If we
1603                            can not reopen the file, for example if we
1604                            reconnected to a server with another client
1605                            racing to delete or lock the file we would not
1606                            make progress if we restarted before the beginning
1607                            of the loop here. */
1608                 }
1609         }
1610         /* couldn't find useable FH with same pid, try any available */
1611         if (!any_available) {
1612                 any_available = true;
1613                 goto refind_writable;
1614         }
1615         spin_unlock(&cifs_file_list_lock);
1616         return NULL;
1617 }
1618
1619 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1620 {
1621         struct address_space *mapping = page->mapping;
1622         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1623         char *write_data;
1624         int rc = -EFAULT;
1625         int bytes_written = 0;
1626         struct inode *inode;
1627         struct cifsFileInfo *open_file;
1628
1629         if (!mapping || !mapping->host)
1630                 return -EFAULT;
1631
1632         inode = page->mapping->host;
1633
1634         offset += (loff_t)from;
1635         write_data = kmap(page);
1636         write_data += from;
1637
1638         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1639                 kunmap(page);
1640                 return -EIO;
1641         }
1642
1643         /* racing with truncate? */
1644         if (offset > mapping->host->i_size) {
1645                 kunmap(page);
1646                 return 0; /* don't care */
1647         }
1648
1649         /* check to make sure that we are not extending the file */
1650         if (mapping->host->i_size - offset < (loff_t)to)
1651                 to = (unsigned)(mapping->host->i_size - offset);
1652
1653         open_file = find_writable_file(CIFS_I(mapping->host), false);
1654         if (open_file) {
1655                 bytes_written = cifs_write(open_file, open_file->pid,
1656                                            write_data, to - from, &offset);
1657                 cifsFileInfo_put(open_file);
1658                 /* Does mm or vfs already set times? */
1659                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1660                 if ((bytes_written > 0) && (offset))
1661                         rc = 0;
1662                 else if (bytes_written < 0)
1663                         rc = bytes_written;
1664         } else {
1665                 cFYI(1, "No writeable filehandles for inode");
1666                 rc = -EIO;
1667         }
1668
1669         kunmap(page);
1670         return rc;
1671 }
1672
1673 /*
1674  * Marshal up the iov array, reserving the first one for the header. Also,
1675  * set wdata->bytes.
1676  */
1677 static void
1678 cifs_writepages_marshal_iov(struct kvec *iov, struct cifs_writedata *wdata)
1679 {
1680         int i;
1681         struct inode *inode = wdata->cfile->dentry->d_inode;
1682         loff_t size = i_size_read(inode);
1683
1684         /* marshal up the pages into iov array */
1685         wdata->bytes = 0;
1686         for (i = 0; i < wdata->nr_pages; i++) {
1687                 iov[i + 1].iov_len = min(size - page_offset(wdata->pages[i]),
1688                                         (loff_t)PAGE_CACHE_SIZE);
1689                 iov[i + 1].iov_base = kmap(wdata->pages[i]);
1690                 wdata->bytes += iov[i + 1].iov_len;
1691         }
1692 }
1693
1694 static int cifs_writepages(struct address_space *mapping,
1695                            struct writeback_control *wbc)
1696 {
1697         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1698         bool done = false, scanned = false, range_whole = false;
1699         pgoff_t end, index;
1700         struct cifs_writedata *wdata;
1701         struct page *page;
1702         int rc = 0;
1703
1704         /*
1705          * If wsize is smaller than the page cache size, default to writing
1706          * one page at a time via cifs_writepage
1707          */
1708         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1709                 return generic_writepages(mapping, wbc);
1710
1711         if (wbc->range_cyclic) {
1712                 index = mapping->writeback_index; /* Start from prev offset */
1713                 end = -1;
1714         } else {
1715                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1716                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1717                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1718                         range_whole = true;
1719                 scanned = true;
1720         }
1721 retry:
1722         while (!done && index <= end) {
1723                 unsigned int i, nr_pages, found_pages;
1724                 pgoff_t next = 0, tofind;
1725                 struct page **pages;
1726
1727                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1728                                 end - index) + 1;
1729
1730                 wdata = cifs_writedata_alloc((unsigned int)tofind,
1731                                              cifs_writev_complete);
1732                 if (!wdata) {
1733                         rc = -ENOMEM;
1734                         break;
1735                 }
1736
1737                 /*
1738                  * find_get_pages_tag seems to return a max of 256 on each
1739                  * iteration, so we must call it several times in order to
1740                  * fill the array or the wsize is effectively limited to
1741                  * 256 * PAGE_CACHE_SIZE.
1742                  */
1743                 found_pages = 0;
1744                 pages = wdata->pages;
1745                 do {
1746                         nr_pages = find_get_pages_tag(mapping, &index,
1747                                                         PAGECACHE_TAG_DIRTY,
1748                                                         tofind, pages);
1749                         found_pages += nr_pages;
1750                         tofind -= nr_pages;
1751                         pages += nr_pages;
1752                 } while (nr_pages && tofind && index <= end);
1753
1754                 if (found_pages == 0) {
1755                         kref_put(&wdata->refcount, cifs_writedata_release);
1756                         break;
1757                 }
1758
1759                 nr_pages = 0;
1760                 for (i = 0; i < found_pages; i++) {
1761                         page = wdata->pages[i];
1762                         /*
1763                          * At this point we hold neither mapping->tree_lock nor
1764                          * lock on the page itself: the page may be truncated or
1765                          * invalidated (changing page->mapping to NULL), or even
1766                          * swizzled back from swapper_space to tmpfs file
1767                          * mapping
1768                          */
1769
1770                         if (nr_pages == 0)
1771                                 lock_page(page);
1772                         else if (!trylock_page(page))
1773                                 break;
1774
1775                         if (unlikely(page->mapping != mapping)) {
1776                                 unlock_page(page);
1777                                 break;
1778                         }
1779
1780                         if (!wbc->range_cyclic && page->index > end) {
1781                                 done = true;
1782                                 unlock_page(page);
1783                                 break;
1784                         }
1785
1786                         if (next && (page->index != next)) {
1787                                 /* Not next consecutive page */
1788                                 unlock_page(page);
1789                                 break;
1790                         }
1791
1792                         if (wbc->sync_mode != WB_SYNC_NONE)
1793                                 wait_on_page_writeback(page);
1794
1795                         if (PageWriteback(page) ||
1796                                         !clear_page_dirty_for_io(page)) {
1797                                 unlock_page(page);
1798                                 break;
1799                         }
1800
1801                         /*
1802                          * This actually clears the dirty bit in the radix tree.
1803                          * See cifs_writepage() for more commentary.
1804                          */
1805                         set_page_writeback(page);
1806
1807                         if (page_offset(page) >= mapping->host->i_size) {
1808                                 done = true;
1809                                 unlock_page(page);
1810                                 end_page_writeback(page);
1811                                 break;
1812                         }
1813
1814                         wdata->pages[i] = page;
1815                         next = page->index + 1;
1816                         ++nr_pages;
1817                 }
1818
1819                 /* reset index to refind any pages skipped */
1820                 if (nr_pages == 0)
1821                         index = wdata->pages[0]->index + 1;
1822
1823                 /* put any pages we aren't going to use */
1824                 for (i = nr_pages; i < found_pages; i++) {
1825                         page_cache_release(wdata->pages[i]);
1826                         wdata->pages[i] = NULL;
1827                 }
1828
1829                 /* nothing to write? */
1830                 if (nr_pages == 0) {
1831                         kref_put(&wdata->refcount, cifs_writedata_release);
1832                         continue;
1833                 }
1834
1835                 wdata->sync_mode = wbc->sync_mode;
1836                 wdata->nr_pages = nr_pages;
1837                 wdata->offset = page_offset(wdata->pages[0]);
1838                 wdata->marshal_iov = cifs_writepages_marshal_iov;
1839
1840                 do {
1841                         if (wdata->cfile != NULL)
1842                                 cifsFileInfo_put(wdata->cfile);
1843                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1844                                                           false);
1845                         if (!wdata->cfile) {
1846                                 cERROR(1, "No writable handles for inode");
1847                                 rc = -EBADF;
1848                                 break;
1849                         }
1850                         wdata->pid = wdata->cfile->pid;
1851                         rc = cifs_async_writev(wdata);
1852                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1853
1854                 for (i = 0; i < nr_pages; ++i)
1855                         unlock_page(wdata->pages[i]);
1856
1857                 /* send failure -- clean up the mess */
1858                 if (rc != 0) {
1859                         for (i = 0; i < nr_pages; ++i) {
1860                                 if (rc == -EAGAIN)
1861                                         redirty_page_for_writepage(wbc,
1862                                                            wdata->pages[i]);
1863                                 else
1864                                         SetPageError(wdata->pages[i]);
1865                                 end_page_writeback(wdata->pages[i]);
1866                                 page_cache_release(wdata->pages[i]);
1867                         }
1868                         if (rc != -EAGAIN)
1869                                 mapping_set_error(mapping, rc);
1870                 }
1871                 kref_put(&wdata->refcount, cifs_writedata_release);
1872
1873                 wbc->nr_to_write -= nr_pages;
1874                 if (wbc->nr_to_write <= 0)
1875                         done = true;
1876
1877                 index = next;
1878         }
1879
1880         if (!scanned && !done) {
1881                 /*
1882                  * We hit the last page and there is more work to be done: wrap
1883                  * back to the start of the file
1884                  */
1885                 scanned = true;
1886                 index = 0;
1887                 goto retry;
1888         }
1889
1890         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1891                 mapping->writeback_index = index;
1892
1893         return rc;
1894 }
1895
1896 static int
1897 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1898 {
1899         int rc;
1900         int xid;
1901
1902         xid = GetXid();
1903 /* BB add check for wbc flags */
1904         page_cache_get(page);
1905         if (!PageUptodate(page))
1906                 cFYI(1, "ppw - page not up to date");
1907
1908         /*
1909          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1910          *
1911          * A writepage() implementation always needs to do either this,
1912          * or re-dirty the page with "redirty_page_for_writepage()" in
1913          * the case of a failure.
1914          *
1915          * Just unlocking the page will cause the radix tree tag-bits
1916          * to fail to update with the state of the page correctly.
1917          */
1918         set_page_writeback(page);
1919 retry_write:
1920         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1921         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1922                 goto retry_write;
1923         else if (rc == -EAGAIN)
1924                 redirty_page_for_writepage(wbc, page);
1925         else if (rc != 0)
1926                 SetPageError(page);
1927         else
1928                 SetPageUptodate(page);
1929         end_page_writeback(page);
1930         page_cache_release(page);
1931         FreeXid(xid);
1932         return rc;
1933 }
1934
1935 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1936 {
1937         int rc = cifs_writepage_locked(page, wbc);
1938         unlock_page(page);
1939         return rc;
1940 }
1941
1942 static int cifs_write_end(struct file *file, struct address_space *mapping,
1943                         loff_t pos, unsigned len, unsigned copied,
1944                         struct page *page, void *fsdata)
1945 {
1946         int rc;
1947         struct inode *inode = mapping->host;
1948         struct cifsFileInfo *cfile = file->private_data;
1949         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1950         __u32 pid;
1951
1952         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1953                 pid = cfile->pid;
1954         else
1955                 pid = current->tgid;
1956
1957         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1958                  page, pos, copied);
1959
1960         if (PageChecked(page)) {
1961                 if (copied == len)
1962                         SetPageUptodate(page);
1963                 ClearPageChecked(page);
1964         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1965                 SetPageUptodate(page);
1966
1967         if (!PageUptodate(page)) {
1968                 char *page_data;
1969                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1970                 int xid;
1971
1972                 xid = GetXid();
1973                 /* this is probably better than directly calling
1974                    partialpage_write since in this function the file handle is
1975                    known which we might as well leverage */
1976                 /* BB check if anything else missing out of ppw
1977                    such as updating last write time */
1978                 page_data = kmap(page);
1979                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1980                 /* if (rc < 0) should we set writebehind rc? */
1981                 kunmap(page);
1982
1983                 FreeXid(xid);
1984         } else {
1985                 rc = copied;
1986                 pos += copied;
1987                 set_page_dirty(page);
1988         }
1989
1990         if (rc > 0) {
1991                 spin_lock(&inode->i_lock);
1992                 if (pos > inode->i_size)
1993                         i_size_write(inode, pos);
1994                 spin_unlock(&inode->i_lock);
1995         }
1996
1997         unlock_page(page);
1998         page_cache_release(page);
1999
2000         return rc;
2001 }
2002
2003 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2004                       int datasync)
2005 {
2006         int xid;
2007         int rc = 0;
2008         struct cifs_tcon *tcon;
2009         struct cifsFileInfo *smbfile = file->private_data;
2010         struct inode *inode = file->f_path.dentry->d_inode;
2011         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2012
2013         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2014         if (rc)
2015                 return rc;
2016         mutex_lock(&inode->i_mutex);
2017
2018         xid = GetXid();
2019
2020         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2021                 file->f_path.dentry->d_name.name, datasync);
2022
2023         if (!CIFS_I(inode)->clientCanCacheRead) {
2024                 rc = cifs_invalidate_mapping(inode);
2025                 if (rc) {
2026                         cFYI(1, "rc: %d during invalidate phase", rc);
2027                         rc = 0; /* don't care about it in fsync */
2028                 }
2029         }
2030
2031         tcon = tlink_tcon(smbfile->tlink);
2032         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2033                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2034
2035         FreeXid(xid);
2036         mutex_unlock(&inode->i_mutex);
2037         return rc;
2038 }
2039
2040 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2041 {
2042         int xid;
2043         int rc = 0;
2044         struct cifs_tcon *tcon;
2045         struct cifsFileInfo *smbfile = file->private_data;
2046         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2047         struct inode *inode = file->f_mapping->host;
2048
2049         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2050         if (rc)
2051                 return rc;
2052         mutex_lock(&inode->i_mutex);
2053
2054         xid = GetXid();
2055
2056         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2057                 file->f_path.dentry->d_name.name, datasync);
2058
2059         tcon = tlink_tcon(smbfile->tlink);
2060         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2061                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2062
2063         FreeXid(xid);
2064         mutex_unlock(&inode->i_mutex);
2065         return rc;
2066 }
2067
2068 /*
2069  * As file closes, flush all cached write data for this inode checking
2070  * for write behind errors.
2071  */
2072 int cifs_flush(struct file *file, fl_owner_t id)
2073 {
2074         struct inode *inode = file->f_path.dentry->d_inode;
2075         int rc = 0;
2076
2077         if (file->f_mode & FMODE_WRITE)
2078                 rc = filemap_write_and_wait(inode->i_mapping);
2079
2080         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2081
2082         return rc;
2083 }
2084
2085 static int
2086 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2087 {
2088         int rc = 0;
2089         unsigned long i;
2090
2091         for (i = 0; i < num_pages; i++) {
2092                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2093                 if (!pages[i]) {
2094                         /*
2095                          * save number of pages we have already allocated and
2096                          * return with ENOMEM error
2097                          */
2098                         num_pages = i;
2099                         rc = -ENOMEM;
2100                         break;
2101                 }
2102         }
2103
2104         if (rc) {
2105                 for (i = 0; i < num_pages; i++)
2106                         put_page(pages[i]);
2107         }
2108         return rc;
2109 }
2110
2111 static inline
2112 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2113 {
2114         size_t num_pages;
2115         size_t clen;
2116
2117         clen = min_t(const size_t, len, wsize);
2118         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2119
2120         if (cur_len)
2121                 *cur_len = clen;
2122
2123         return num_pages;
2124 }
2125
2126 static void
2127 cifs_uncached_marshal_iov(struct kvec *iov, struct cifs_writedata *wdata)
2128 {
2129         int i;
2130         size_t bytes = wdata->bytes;
2131
2132         /* marshal up the pages into iov array */
2133         for (i = 0; i < wdata->nr_pages; i++) {
2134                 iov[i + 1].iov_len = min_t(size_t, bytes, PAGE_SIZE);
2135                 iov[i + 1].iov_base = kmap(wdata->pages[i]);
2136                 bytes -= iov[i + 1].iov_len;
2137         }
2138 }
2139
2140 static void
2141 cifs_uncached_writev_complete(struct work_struct *work)
2142 {
2143         int i;
2144         struct cifs_writedata *wdata = container_of(work,
2145                                         struct cifs_writedata, work);
2146         struct inode *inode = wdata->cfile->dentry->d_inode;
2147         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2148
2149         spin_lock(&inode->i_lock);
2150         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2151         if (cifsi->server_eof > inode->i_size)
2152                 i_size_write(inode, cifsi->server_eof);
2153         spin_unlock(&inode->i_lock);
2154
2155         complete(&wdata->done);
2156
2157         if (wdata->result != -EAGAIN) {
2158                 for (i = 0; i < wdata->nr_pages; i++)
2159                         put_page(wdata->pages[i]);
2160         }
2161
2162         kref_put(&wdata->refcount, cifs_writedata_release);
2163 }
2164
2165 /* attempt to send write to server, retry on any -EAGAIN errors */
2166 static int
2167 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2168 {
2169         int rc;
2170
2171         do {
2172                 if (wdata->cfile->invalidHandle) {
2173                         rc = cifs_reopen_file(wdata->cfile, false);
2174                         if (rc != 0)
2175                                 continue;
2176                 }
2177                 rc = cifs_async_writev(wdata);
2178         } while (rc == -EAGAIN);
2179
2180         return rc;
2181 }
2182
2183 static ssize_t
2184 cifs_iovec_write(struct file *file, const struct iovec *iov,
2185                  unsigned long nr_segs, loff_t *poffset)
2186 {
2187         unsigned long nr_pages, i;
2188         size_t copied, len, cur_len;
2189         ssize_t total_written = 0;
2190         loff_t offset;
2191         struct iov_iter it;
2192         struct cifsFileInfo *open_file;
2193         struct cifs_tcon *tcon;
2194         struct cifs_sb_info *cifs_sb;
2195         struct cifs_writedata *wdata, *tmp;
2196         struct list_head wdata_list;
2197         int rc;
2198         pid_t pid;
2199
2200         len = iov_length(iov, nr_segs);
2201         if (!len)
2202                 return 0;
2203
2204         rc = generic_write_checks(file, poffset, &len, 0);
2205         if (rc)
2206                 return rc;
2207
2208         INIT_LIST_HEAD(&wdata_list);
2209         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2210         open_file = file->private_data;
2211         tcon = tlink_tcon(open_file->tlink);
2212         offset = *poffset;
2213
2214         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2215                 pid = open_file->pid;
2216         else
2217                 pid = current->tgid;
2218
2219         iov_iter_init(&it, iov, nr_segs, len, 0);
2220         do {
2221                 size_t save_len;
2222
2223                 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2224                 wdata = cifs_writedata_alloc(nr_pages,
2225                                              cifs_uncached_writev_complete);
2226                 if (!wdata) {
2227                         rc = -ENOMEM;
2228                         break;
2229                 }
2230
2231                 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2232                 if (rc) {
2233                         kfree(wdata);
2234                         break;
2235                 }
2236
2237                 save_len = cur_len;
2238                 for (i = 0; i < nr_pages; i++) {
2239                         copied = min_t(const size_t, cur_len, PAGE_SIZE);
2240                         copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2241                                                          0, copied);
2242                         cur_len -= copied;
2243                         iov_iter_advance(&it, copied);
2244                 }
2245                 cur_len = save_len - cur_len;
2246
2247                 wdata->sync_mode = WB_SYNC_ALL;
2248                 wdata->nr_pages = nr_pages;
2249                 wdata->offset = (__u64)offset;
2250                 wdata->cfile = cifsFileInfo_get(open_file);
2251                 wdata->pid = pid;
2252                 wdata->bytes = cur_len;
2253                 wdata->marshal_iov = cifs_uncached_marshal_iov;
2254                 rc = cifs_uncached_retry_writev(wdata);
2255                 if (rc) {
2256                         kref_put(&wdata->refcount, cifs_writedata_release);
2257                         break;
2258                 }
2259
2260                 list_add_tail(&wdata->list, &wdata_list);
2261                 offset += cur_len;
2262                 len -= cur_len;
2263         } while (len > 0);
2264
2265         /*
2266          * If at least one write was successfully sent, then discard any rc
2267          * value from the later writes. If the other write succeeds, then
2268          * we'll end up returning whatever was written. If it fails, then
2269          * we'll get a new rc value from that.
2270          */
2271         if (!list_empty(&wdata_list))
2272                 rc = 0;
2273
2274         /*
2275          * Wait for and collect replies for any successful sends in order of
2276          * increasing offset. Once an error is hit or we get a fatal signal
2277          * while waiting, then return without waiting for any more replies.
2278          */
2279 restart_loop:
2280         list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2281                 if (!rc) {
2282                         /* FIXME: freezable too? */
2283                         rc = wait_for_completion_killable(&wdata->done);
2284                         if (rc)
2285                                 rc = -EINTR;
2286                         else if (wdata->result)
2287                                 rc = wdata->result;
2288                         else
2289                                 total_written += wdata->bytes;
2290
2291                         /* resend call if it's a retryable error */
2292                         if (rc == -EAGAIN) {
2293                                 rc = cifs_uncached_retry_writev(wdata);
2294                                 goto restart_loop;
2295                         }
2296                 }
2297                 list_del_init(&wdata->list);
2298                 kref_put(&wdata->refcount, cifs_writedata_release);
2299         }
2300
2301         if (total_written > 0)
2302                 *poffset += total_written;
2303
2304         cifs_stats_bytes_written(tcon, total_written);
2305         return total_written ? total_written : (ssize_t)rc;
2306 }
2307
2308 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2309                                 unsigned long nr_segs, loff_t pos)
2310 {
2311         ssize_t written;
2312         struct inode *inode;
2313
2314         inode = iocb->ki_filp->f_path.dentry->d_inode;
2315
2316         /*
2317          * BB - optimize the way when signing is disabled. We can drop this
2318          * extra memory-to-memory copying and use iovec buffers for constructing
2319          * write request.
2320          */
2321
2322         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2323         if (written > 0) {
2324                 CIFS_I(inode)->invalid_mapping = true;
2325                 iocb->ki_pos = pos;
2326         }
2327
2328         return written;
2329 }
2330
2331 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2332                            unsigned long nr_segs, loff_t pos)
2333 {
2334         struct inode *inode;
2335
2336         inode = iocb->ki_filp->f_path.dentry->d_inode;
2337
2338         if (CIFS_I(inode)->clientCanCacheAll)
2339                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2340
2341         /*
2342          * In strict cache mode we need to write the data to the server exactly
2343          * from the pos to pos+len-1 rather than flush all affected pages
2344          * because it may cause a error with mandatory locks on these pages but
2345          * not on the region from pos to ppos+len-1.
2346          */
2347
2348         return cifs_user_writev(iocb, iov, nr_segs, pos);
2349 }
2350
2351 static struct cifs_readdata *
2352 cifs_readdata_alloc(unsigned int nr_vecs, work_func_t complete)
2353 {
2354         struct cifs_readdata *rdata;
2355
2356         rdata = kzalloc(sizeof(*rdata) +
2357                         sizeof(struct kvec) * nr_vecs, GFP_KERNEL);
2358         if (rdata != NULL) {
2359                 kref_init(&rdata->refcount);
2360                 INIT_LIST_HEAD(&rdata->list);
2361                 init_completion(&rdata->done);
2362                 INIT_WORK(&rdata->work, complete);
2363                 INIT_LIST_HEAD(&rdata->pages);
2364         }
2365         return rdata;
2366 }
2367
2368 void
2369 cifs_readdata_release(struct kref *refcount)
2370 {
2371         struct cifs_readdata *rdata = container_of(refcount,
2372                                         struct cifs_readdata, refcount);
2373
2374         if (rdata->cfile)
2375                 cifsFileInfo_put(rdata->cfile);
2376
2377         kfree(rdata);
2378 }
2379
2380 static int
2381 cifs_read_allocate_pages(struct list_head *list, unsigned int npages)
2382 {
2383         int rc = 0;
2384         struct page *page, *tpage;
2385         unsigned int i;
2386
2387         for (i = 0; i < npages; i++) {
2388                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2389                 if (!page) {
2390                         rc = -ENOMEM;
2391                         break;
2392                 }
2393                 list_add(&page->lru, list);
2394         }
2395
2396         if (rc) {
2397                 list_for_each_entry_safe(page, tpage, list, lru) {
2398                         list_del(&page->lru);
2399                         put_page(page);
2400                 }
2401         }
2402         return rc;
2403 }
2404
2405 static void
2406 cifs_uncached_readdata_release(struct kref *refcount)
2407 {
2408         struct page *page, *tpage;
2409         struct cifs_readdata *rdata = container_of(refcount,
2410                                         struct cifs_readdata, refcount);
2411
2412         list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2413                 list_del(&page->lru);
2414                 put_page(page);
2415         }
2416         cifs_readdata_release(refcount);
2417 }
2418
2419 static int
2420 cifs_retry_async_readv(struct cifs_readdata *rdata)
2421 {
2422         int rc;
2423
2424         do {
2425                 if (rdata->cfile->invalidHandle) {
2426                         rc = cifs_reopen_file(rdata->cfile, true);
2427                         if (rc != 0)
2428                                 continue;
2429                 }
2430                 rc = cifs_async_readv(rdata);
2431         } while (rc == -EAGAIN);
2432
2433         return rc;
2434 }
2435
2436 /**
2437  * cifs_readdata_to_iov - copy data from pages in response to an iovec
2438  * @rdata:      the readdata response with list of pages holding data
2439  * @iov:        vector in which we should copy the data
2440  * @nr_segs:    number of segments in vector
2441  * @offset:     offset into file of the first iovec
2442  * @copied:     used to return the amount of data copied to the iov
2443  *
2444  * This function copies data from a list of pages in a readdata response into
2445  * an array of iovecs. It will first calculate where the data should go
2446  * based on the info in the readdata and then copy the data into that spot.
2447  */
2448 static ssize_t
2449 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2450                         unsigned long nr_segs, loff_t offset, ssize_t *copied)
2451 {
2452         int rc = 0;
2453         struct iov_iter ii;
2454         size_t pos = rdata->offset - offset;
2455         struct page *page, *tpage;
2456         ssize_t remaining = rdata->bytes;
2457         unsigned char *pdata;
2458
2459         /* set up iov_iter and advance to the correct offset */
2460         iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2461         iov_iter_advance(&ii, pos);
2462
2463         *copied = 0;
2464         list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2465                 ssize_t copy;
2466
2467                 /* copy a whole page or whatever's left */
2468                 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2469
2470                 /* ...but limit it to whatever space is left in the iov */
2471                 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2472
2473                 /* go while there's data to be copied and no errors */
2474                 if (copy && !rc) {
2475                         pdata = kmap(page);
2476                         rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2477                                                 (int)copy);
2478                         kunmap(page);
2479                         if (!rc) {
2480                                 *copied += copy;
2481                                 remaining -= copy;
2482                                 iov_iter_advance(&ii, copy);
2483                         }
2484                 }
2485
2486                 list_del(&page->lru);
2487                 put_page(page);
2488         }
2489
2490         return rc;
2491 }
2492
2493 static void
2494 cifs_uncached_readv_complete(struct work_struct *work)
2495 {
2496         struct cifs_readdata *rdata = container_of(work,
2497                                                 struct cifs_readdata, work);
2498
2499         /* if the result is non-zero then the pages weren't kmapped */
2500         if (rdata->result == 0) {
2501                 struct page *page;
2502
2503                 list_for_each_entry(page, &rdata->pages, lru)
2504                         kunmap(page);
2505         }
2506
2507         complete(&rdata->done);
2508         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2509 }
2510
2511 static int
2512 cifs_uncached_read_marshal_iov(struct cifs_readdata *rdata,
2513                                 unsigned int remaining)
2514 {
2515         int len = 0;
2516         struct page *page, *tpage;
2517
2518         rdata->nr_iov = 1;
2519         list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2520                 if (remaining >= PAGE_SIZE) {
2521                         /* enough data to fill the page */
2522                         rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2523                         rdata->iov[rdata->nr_iov].iov_len = PAGE_SIZE;
2524                         cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2525                                 rdata->nr_iov, page->index,
2526                                 rdata->iov[rdata->nr_iov].iov_base,
2527                                 rdata->iov[rdata->nr_iov].iov_len);
2528                         ++rdata->nr_iov;
2529                         len += PAGE_SIZE;
2530                         remaining -= PAGE_SIZE;
2531                 } else if (remaining > 0) {
2532                         /* enough for partial page, fill and zero the rest */
2533                         rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2534                         rdata->iov[rdata->nr_iov].iov_len = remaining;
2535                         cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2536                                 rdata->nr_iov, page->index,
2537                                 rdata->iov[rdata->nr_iov].iov_base,
2538                                 rdata->iov[rdata->nr_iov].iov_len);
2539                         memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
2540                                 '\0', PAGE_SIZE - remaining);
2541                         ++rdata->nr_iov;
2542                         len += remaining;
2543                         remaining = 0;
2544                 } else {
2545                         /* no need to hold page hostage */
2546                         list_del(&page->lru);
2547                         put_page(page);
2548                 }
2549         }
2550
2551         return len;
2552 }
2553
2554 static ssize_t
2555 cifs_iovec_read(struct file *file, const struct iovec *iov,
2556                  unsigned long nr_segs, loff_t *poffset)
2557 {
2558         ssize_t rc;
2559         size_t len, cur_len;
2560         ssize_t total_read = 0;
2561         loff_t offset = *poffset;
2562         unsigned int npages;
2563         struct cifs_sb_info *cifs_sb;
2564         struct cifs_tcon *tcon;
2565         struct cifsFileInfo *open_file;
2566         struct cifs_readdata *rdata, *tmp;
2567         struct list_head rdata_list;
2568         pid_t pid;
2569
2570         if (!nr_segs)
2571                 return 0;
2572
2573         len = iov_length(iov, nr_segs);
2574         if (!len)
2575                 return 0;
2576
2577         INIT_LIST_HEAD(&rdata_list);
2578         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2579         open_file = file->private_data;
2580         tcon = tlink_tcon(open_file->tlink);
2581
2582         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2583                 pid = open_file->pid;
2584         else
2585                 pid = current->tgid;
2586
2587         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2588                 cFYI(1, "attempting read on write only file instance");
2589
2590         do {
2591                 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2592                 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2593
2594                 /* allocate a readdata struct */
2595                 rdata = cifs_readdata_alloc(npages,
2596                                             cifs_uncached_readv_complete);
2597                 if (!rdata) {
2598                         rc = -ENOMEM;
2599                         goto error;
2600                 }
2601
2602                 rc = cifs_read_allocate_pages(&rdata->pages, npages);
2603                 if (rc)
2604                         goto error;
2605
2606                 rdata->cfile = cifsFileInfo_get(open_file);
2607                 rdata->offset = offset;
2608                 rdata->bytes = cur_len;
2609                 rdata->pid = pid;
2610                 rdata->marshal_iov = cifs_uncached_read_marshal_iov;
2611
2612                 rc = cifs_retry_async_readv(rdata);
2613 error:
2614                 if (rc) {
2615                         kref_put(&rdata->refcount,
2616                                  cifs_uncached_readdata_release);
2617                         break;
2618                 }
2619
2620                 list_add_tail(&rdata->list, &rdata_list);
2621                 offset += cur_len;
2622                 len -= cur_len;
2623         } while (len > 0);
2624
2625         /* if at least one read request send succeeded, then reset rc */
2626         if (!list_empty(&rdata_list))
2627                 rc = 0;
2628
2629         /* the loop below should proceed in the order of increasing offsets */
2630 restart_loop:
2631         list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2632                 if (!rc) {
2633                         ssize_t copied;
2634
2635                         /* FIXME: freezable sleep too? */
2636                         rc = wait_for_completion_killable(&rdata->done);
2637                         if (rc)
2638                                 rc = -EINTR;
2639                         else if (rdata->result)
2640                                 rc = rdata->result;
2641                         else {
2642                                 rc = cifs_readdata_to_iov(rdata, iov,
2643                                                         nr_segs, *poffset,
2644                                                         &copied);
2645                                 total_read += copied;
2646                         }
2647
2648                         /* resend call if it's a retryable error */
2649                         if (rc == -EAGAIN) {
2650                                 rc = cifs_retry_async_readv(rdata);
2651                                 goto restart_loop;
2652                         }
2653                 }
2654                 list_del_init(&rdata->list);
2655                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2656         }
2657
2658         cifs_stats_bytes_read(tcon, total_read);
2659         *poffset += total_read;
2660
2661         return total_read ? total_read : rc;
2662 }
2663
2664 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2665                                unsigned long nr_segs, loff_t pos)
2666 {
2667         ssize_t read;
2668
2669         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2670         if (read > 0)
2671                 iocb->ki_pos = pos;
2672
2673         return read;
2674 }
2675
2676 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2677                           unsigned long nr_segs, loff_t pos)
2678 {
2679         struct inode *inode;
2680
2681         inode = iocb->ki_filp->f_path.dentry->d_inode;
2682
2683         if (CIFS_I(inode)->clientCanCacheRead)
2684                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2685
2686         /*
2687          * In strict cache mode we need to read from the server all the time
2688          * if we don't have level II oplock because the server can delay mtime
2689          * change - so we can't make a decision about inode invalidating.
2690          * And we can also fail with pagereading if there are mandatory locks
2691          * on pages affected by this read but not on the region from pos to
2692          * pos+len-1.
2693          */
2694
2695         return cifs_user_readv(iocb, iov, nr_segs, pos);
2696 }
2697
2698 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2699                          loff_t *poffset)
2700 {
2701         int rc = -EACCES;
2702         unsigned int bytes_read = 0;
2703         unsigned int total_read;
2704         unsigned int current_read_size;
2705         unsigned int rsize;
2706         struct cifs_sb_info *cifs_sb;
2707         struct cifs_tcon *pTcon;
2708         int xid;
2709         char *current_offset;
2710         struct cifsFileInfo *open_file;
2711         struct cifs_io_parms io_parms;
2712         int buf_type = CIFS_NO_BUFFER;
2713         __u32 pid;
2714
2715         xid = GetXid();
2716         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2717
2718         /* FIXME: set up handlers for larger reads and/or convert to async */
2719         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2720
2721         if (file->private_data == NULL) {
2722                 rc = -EBADF;
2723                 FreeXid(xid);
2724                 return rc;
2725         }
2726         open_file = file->private_data;
2727         pTcon = tlink_tcon(open_file->tlink);
2728
2729         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2730                 pid = open_file->pid;
2731         else
2732                 pid = current->tgid;
2733
2734         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2735                 cFYI(1, "attempting read on write only file instance");
2736
2737         for (total_read = 0, current_offset = read_data;
2738              read_size > total_read;
2739              total_read += bytes_read, current_offset += bytes_read) {
2740                 current_read_size = min_t(uint, read_size - total_read, rsize);
2741
2742                 /* For windows me and 9x we do not want to request more
2743                 than it negotiated since it will refuse the read then */
2744                 if ((pTcon->ses) &&
2745                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2746                         current_read_size = min_t(uint, current_read_size,
2747                                         CIFSMaxBufSize);
2748                 }
2749                 rc = -EAGAIN;
2750                 while (rc == -EAGAIN) {
2751                         if (open_file->invalidHandle) {
2752                                 rc = cifs_reopen_file(open_file, true);
2753                                 if (rc != 0)
2754                                         break;
2755                         }
2756                         io_parms.netfid = open_file->netfid;
2757                         io_parms.pid = pid;
2758                         io_parms.tcon = pTcon;
2759                         io_parms.offset = *poffset;
2760                         io_parms.length = current_read_size;
2761                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2762                                          &current_offset, &buf_type);
2763                 }
2764                 if (rc || (bytes_read == 0)) {
2765                         if (total_read) {
2766                                 break;
2767                         } else {
2768                                 FreeXid(xid);
2769                                 return rc;
2770                         }
2771                 } else {
2772                         cifs_stats_bytes_read(pTcon, total_read);
2773                         *poffset += bytes_read;
2774                 }
2775         }
2776         FreeXid(xid);
2777         return total_read;
2778 }
2779
2780 /*
2781  * If the page is mmap'ed into a process' page tables, then we need to make
2782  * sure that it doesn't change while being written back.
2783  */
2784 static int
2785 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2786 {
2787         struct page *page = vmf->page;
2788
2789         lock_page(page);
2790         return VM_FAULT_LOCKED;
2791 }
2792
2793 static struct vm_operations_struct cifs_file_vm_ops = {
2794         .fault = filemap_fault,
2795         .page_mkwrite = cifs_page_mkwrite,
2796 };
2797
2798 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2799 {
2800         int rc, xid;
2801         struct inode *inode = file->f_path.dentry->d_inode;
2802
2803         xid = GetXid();
2804
2805         if (!CIFS_I(inode)->clientCanCacheRead) {
2806                 rc = cifs_invalidate_mapping(inode);
2807                 if (rc)
2808                         return rc;
2809         }
2810
2811         rc = generic_file_mmap(file, vma);
2812         if (rc == 0)
2813                 vma->vm_ops = &cifs_file_vm_ops;
2814         FreeXid(xid);
2815         return rc;
2816 }
2817
2818 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2819 {
2820         int rc, xid;
2821
2822         xid = GetXid();
2823         rc = cifs_revalidate_file(file);
2824         if (rc) {
2825                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2826                 FreeXid(xid);
2827                 return rc;
2828         }
2829         rc = generic_file_mmap(file, vma);
2830         if (rc == 0)
2831                 vma->vm_ops = &cifs_file_vm_ops;
2832         FreeXid(xid);
2833         return rc;
2834 }
2835
2836 static void
2837 cifs_readv_complete(struct work_struct *work)
2838 {
2839         struct cifs_readdata *rdata = container_of(work,
2840                                                 struct cifs_readdata, work);
2841         struct page *page, *tpage;
2842
2843         list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2844                 list_del(&page->lru);
2845                 lru_cache_add_file(page);
2846
2847                 if (rdata->result == 0) {
2848                         kunmap(page);
2849                         flush_dcache_page(page);
2850                         SetPageUptodate(page);
2851                 }
2852
2853                 unlock_page(page);
2854
2855                 if (rdata->result == 0)
2856                         cifs_readpage_to_fscache(rdata->mapping->host, page);
2857
2858                 page_cache_release(page);
2859         }
2860         kref_put(&rdata->refcount, cifs_readdata_release);
2861 }
2862
2863 static int
2864 cifs_readpages_marshal_iov(struct cifs_readdata *rdata, unsigned int remaining)
2865 {
2866         int len = 0;
2867         struct page *page, *tpage;
2868         u64 eof;
2869         pgoff_t eof_index;
2870
2871         /* determine the eof that the server (probably) has */
2872         eof = CIFS_I(rdata->mapping->host)->server_eof;
2873         eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
2874         cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
2875
2876         rdata->nr_iov = 1;
2877         list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2878                 if (remaining >= PAGE_CACHE_SIZE) {
2879                         /* enough data to fill the page */
2880                         rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2881                         rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
2882                         cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2883                                 rdata->nr_iov, page->index,
2884                                 rdata->iov[rdata->nr_iov].iov_base,
2885                                 rdata->iov[rdata->nr_iov].iov_len);
2886                         ++rdata->nr_iov;
2887                         len += PAGE_CACHE_SIZE;
2888                         remaining -= PAGE_CACHE_SIZE;
2889                 } else if (remaining > 0) {
2890                         /* enough for partial page, fill and zero the rest */
2891                         rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2892                         rdata->iov[rdata->nr_iov].iov_len = remaining;
2893                         cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2894                                 rdata->nr_iov, page->index,
2895                                 rdata->iov[rdata->nr_iov].iov_base,
2896                                 rdata->iov[rdata->nr_iov].iov_len);
2897                         memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
2898                                 '\0', PAGE_CACHE_SIZE - remaining);
2899                         ++rdata->nr_iov;
2900                         len += remaining;
2901                         remaining = 0;
2902                 } else if (page->index > eof_index) {
2903                         /*
2904                          * The VFS will not try to do readahead past the
2905                          * i_size, but it's possible that we have outstanding
2906                          * writes with gaps in the middle and the i_size hasn't
2907                          * caught up yet. Populate those with zeroed out pages
2908                          * to prevent the VFS from repeatedly attempting to
2909                          * fill them until the writes are flushed.
2910                          */
2911                         zero_user(page, 0, PAGE_CACHE_SIZE);
2912                         list_del(&page->lru);
2913                         lru_cache_add_file(page);
2914                         flush_dcache_page(page);
2915                         SetPageUptodate(page);
2916                         unlock_page(page);
2917                         page_cache_release(page);
2918                 } else {
2919                         /* no need to hold page hostage */
2920                         list_del(&page->lru);
2921                         lru_cache_add_file(page);
2922                         unlock_page(page);
2923                         page_cache_release(page);
2924                 }
2925         }
2926
2927         return len;
2928 }
2929
2930 static int cifs_readpages(struct file *file, struct address_space *mapping,
2931         struct list_head *page_list, unsigned num_pages)
2932 {
2933         int rc;
2934         struct list_head tmplist;
2935         struct cifsFileInfo *open_file = file->private_data;
2936         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2937         unsigned int rsize = cifs_sb->rsize;
2938         pid_t pid;
2939
2940         /*
2941          * Give up immediately if rsize is too small to read an entire page.
2942          * The VFS will fall back to readpage. We should never reach this
2943          * point however since we set ra_pages to 0 when the rsize is smaller
2944          * than a cache page.
2945          */
2946         if (unlikely(rsize < PAGE_CACHE_SIZE))
2947                 return 0;
2948
2949         /*
2950          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2951          * immediately if the cookie is negative
2952          */
2953         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2954                                          &num_pages);
2955         if (rc == 0)
2956                 return rc;
2957
2958         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2959                 pid = open_file->pid;
2960         else
2961                 pid = current->tgid;
2962
2963         rc = 0;
2964         INIT_LIST_HEAD(&tmplist);
2965
2966         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2967                 mapping, num_pages);
2968
2969         /*
2970          * Start with the page at end of list and move it to private
2971          * list. Do the same with any following pages until we hit
2972          * the rsize limit, hit an index discontinuity, or run out of
2973          * pages. Issue the async read and then start the loop again
2974          * until the list is empty.
2975          *
2976          * Note that list order is important. The page_list is in
2977          * the order of declining indexes. When we put the pages in
2978          * the rdata->pages, then we want them in increasing order.
2979          */
2980         while (!list_empty(page_list)) {
2981                 unsigned int bytes = PAGE_CACHE_SIZE;
2982                 unsigned int expected_index;
2983                 unsigned int nr_pages = 1;
2984                 loff_t offset;
2985                 struct page *page, *tpage;
2986                 struct cifs_readdata *rdata;
2987
2988                 page = list_entry(page_list->prev, struct page, lru);
2989
2990                 /*
2991                  * Lock the page and put it in the cache. Since no one else
2992                  * should have access to this page, we're safe to simply set
2993                  * PG_locked without checking it first.
2994                  */
2995                 __set_page_locked(page);
2996                 rc = add_to_page_cache_locked(page, mapping,
2997                                               page->index, GFP_KERNEL);
2998
2999                 /* give up if we can't stick it in the cache */
3000                 if (rc) {
3001                         __clear_page_locked(page);
3002                         break;
3003                 }
3004
3005                 /* move first page to the tmplist */
3006                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3007                 list_move_tail(&page->lru, &tmplist);
3008
3009                 /* now try and add more pages onto the request */
3010                 expected_index = page->index + 1;
3011                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3012                         /* discontinuity ? */
3013                         if (page->index != expected_index)
3014                                 break;
3015
3016                         /* would this page push the read over the rsize? */
3017                         if (bytes + PAGE_CACHE_SIZE > rsize)
3018                                 break;
3019
3020                         __set_page_locked(page);
3021                         if (add_to_page_cache_locked(page, mapping,
3022                                                 page->index, GFP_KERNEL)) {
3023                                 __clear_page_locked(page);
3024                                 break;
3025                         }
3026                         list_move_tail(&page->lru, &tmplist);
3027                         bytes += PAGE_CACHE_SIZE;
3028                         expected_index++;
3029                         nr_pages++;
3030                 }
3031
3032                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3033                 if (!rdata) {
3034                         /* best to give up if we're out of mem */
3035                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3036                                 list_del(&page->lru);
3037                                 lru_cache_add_file(page);
3038                                 unlock_page(page);
3039                                 page_cache_release(page);
3040                         }
3041                         rc = -ENOMEM;
3042                         break;
3043                 }
3044
3045                 spin_lock(&cifs_file_list_lock);
3046                 spin_unlock(&cifs_file_list_lock);
3047                 rdata->cfile = cifsFileInfo_get(open_file);
3048                 rdata->mapping = mapping;
3049                 rdata->offset = offset;
3050                 rdata->bytes = bytes;
3051                 rdata->pid = pid;
3052                 rdata->marshal_iov = cifs_readpages_marshal_iov;
3053                 list_splice_init(&tmplist, &rdata->pages);
3054
3055                 rc = cifs_retry_async_readv(rdata);
3056                 if (rc != 0) {
3057                         list_for_each_entry_safe(page, tpage, &rdata->pages,
3058                                                  lru) {
3059                                 list_del(&page->lru);
3060                                 lru_cache_add_file(page);
3061                                 unlock_page(page);
3062                                 page_cache_release(page);
3063                         }
3064                         kref_put(&rdata->refcount, cifs_readdata_release);
3065                         break;
3066                 }
3067
3068                 kref_put(&rdata->refcount, cifs_readdata_release);
3069         }
3070
3071         return rc;
3072 }
3073
3074 static int cifs_readpage_worker(struct file *file, struct page *page,
3075         loff_t *poffset)
3076 {
3077         char *read_data;
3078         int rc;
3079
3080         /* Is the page cached? */
3081         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
3082         if (rc == 0)
3083                 goto read_complete;
3084
3085         page_cache_get(page);
3086         read_data = kmap(page);
3087         /* for reads over a certain size could initiate async read ahead */
3088
3089         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3090
3091         if (rc < 0)
3092                 goto io_error;
3093         else
3094                 cFYI(1, "Bytes read %d", rc);
3095
3096         file->f_path.dentry->d_inode->i_atime =
3097                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
3098
3099         if (PAGE_CACHE_SIZE > rc)
3100                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3101
3102         flush_dcache_page(page);
3103         SetPageUptodate(page);
3104
3105         /* send this page to the cache */
3106         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
3107
3108         rc = 0;
3109
3110 io_error:
3111         kunmap(page);
3112         page_cache_release(page);
3113
3114 read_complete:
3115         return rc;
3116 }
3117
3118 static int cifs_readpage(struct file *file, struct page *page)
3119 {
3120         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3121         int rc = -EACCES;
3122         int xid;
3123
3124         xid = GetXid();
3125
3126         if (file->private_data == NULL) {
3127                 rc = -EBADF;
3128                 FreeXid(xid);
3129                 return rc;
3130         }
3131
3132         cFYI(1, "readpage %p at offset %d 0x%x\n",
3133                  page, (int)offset, (int)offset);
3134
3135         rc = cifs_readpage_worker(file, page, &offset);
3136
3137         unlock_page(page);
3138
3139         FreeXid(xid);
3140         return rc;
3141 }
3142
3143 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3144 {
3145         struct cifsFileInfo *open_file;
3146
3147         spin_lock(&cifs_file_list_lock);
3148         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3149                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3150                         spin_unlock(&cifs_file_list_lock);
3151                         return 1;
3152                 }
3153         }
3154         spin_unlock(&cifs_file_list_lock);
3155         return 0;
3156 }
3157
3158 /* We do not want to update the file size from server for inodes
3159    open for write - to avoid races with writepage extending
3160    the file - in the future we could consider allowing
3161    refreshing the inode only on increases in the file size
3162    but this is tricky to do without racing with writebehind
3163    page caching in the current Linux kernel design */
3164 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3165 {
3166         if (!cifsInode)
3167                 return true;
3168
3169         if (is_inode_writable(cifsInode)) {
3170                 /* This inode is open for write at least once */
3171                 struct cifs_sb_info *cifs_sb;
3172
3173                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3174                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3175                         /* since no page cache to corrupt on directio
3176                         we can change size safely */
3177                         return true;
3178                 }
3179
3180                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3181                         return true;
3182
3183                 return false;
3184         } else
3185                 return true;
3186 }
3187
3188 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3189                         loff_t pos, unsigned len, unsigned flags,
3190                         struct page **pagep, void **fsdata)
3191 {
3192         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3193         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3194         loff_t page_start = pos & PAGE_MASK;
3195         loff_t i_size;
3196         struct page *page;
3197         int rc = 0;
3198
3199         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
3200
3201         page = grab_cache_page_write_begin(mapping, index, flags);
3202         if (!page) {
3203                 rc = -ENOMEM;
3204                 goto out;
3205         }
3206
3207         if (PageUptodate(page))
3208                 goto out;
3209
3210         /*
3211          * If we write a full page it will be up to date, no need to read from
3212          * the server. If the write is short, we'll end up doing a sync write
3213          * instead.
3214          */
3215         if (len == PAGE_CACHE_SIZE)
3216                 goto out;
3217
3218         /*
3219          * optimize away the read when we have an oplock, and we're not
3220          * expecting to use any of the data we'd be reading in. That
3221          * is, when the page lies beyond the EOF, or straddles the EOF
3222          * and the write will cover all of the existing data.
3223          */
3224         if (CIFS_I(mapping->host)->clientCanCacheRead) {
3225                 i_size = i_size_read(mapping->host);
3226                 if (page_start >= i_size ||
3227                     (offset == 0 && (pos + len) >= i_size)) {
3228                         zero_user_segments(page, 0, offset,
3229                                            offset + len,
3230                                            PAGE_CACHE_SIZE);
3231                         /*
3232                          * PageChecked means that the parts of the page
3233                          * to which we're not writing are considered up
3234                          * to date. Once the data is copied to the
3235                          * page, it can be set uptodate.
3236                          */
3237                         SetPageChecked(page);
3238                         goto out;
3239                 }
3240         }
3241
3242         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
3243                 /*
3244                  * might as well read a page, it is fast enough. If we get
3245                  * an error, we don't need to return it. cifs_write_end will
3246                  * do a sync write instead since PG_uptodate isn't set.
3247                  */
3248                 cifs_readpage_worker(file, page, &page_start);
3249         } else {
3250                 /* we could try using another file handle if there is one -
3251                    but how would we lock it to prevent close of that handle
3252                    racing with this read? In any case
3253                    this will be written out by write_end so is fine */
3254         }
3255 out:
3256         *pagep = page;
3257         return rc;
3258 }
3259
3260 static int cifs_release_page(struct page *page, gfp_t gfp)
3261 {
3262         if (PagePrivate(page))
3263                 return 0;
3264
3265         return cifs_fscache_release_page(page, gfp);
3266 }
3267
3268 static void cifs_invalidate_page(struct page *page, unsigned long offset)
3269 {
3270         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3271
3272         if (offset == 0)
3273                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3274 }
3275
3276 static int cifs_launder_page(struct page *page)
3277 {
3278         int rc = 0;
3279         loff_t range_start = page_offset(page);
3280         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3281         struct writeback_control wbc = {
3282                 .sync_mode = WB_SYNC_ALL,
3283                 .nr_to_write = 0,
3284                 .range_start = range_start,
3285                 .range_end = range_end,
3286         };
3287
3288         cFYI(1, "Launder page: %p", page);
3289
3290         if (clear_page_dirty_for_io(page))
3291                 rc = cifs_writepage_locked(page, &wbc);
3292
3293         cifs_fscache_invalidate_page(page, page->mapping->host);
3294         return rc;
3295 }
3296
3297 void cifs_oplock_break(struct work_struct *work)
3298 {
3299         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3300                                                   oplock_break);
3301         struct inode *inode = cfile->dentry->d_inode;
3302         struct cifsInodeInfo *cinode = CIFS_I(inode);
3303         int rc = 0;
3304
3305         if (inode && S_ISREG(inode->i_mode)) {
3306                 if (cinode->clientCanCacheRead)
3307                         break_lease(inode, O_RDONLY);
3308                 else
3309                         break_lease(inode, O_WRONLY);
3310                 rc = filemap_fdatawrite(inode->i_mapping);
3311                 if (cinode->clientCanCacheRead == 0) {
3312                         rc = filemap_fdatawait(inode->i_mapping);
3313                         mapping_set_error(inode->i_mapping, rc);
3314                         invalidate_remote_inode(inode);
3315                 }
3316                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
3317         }
3318
3319         rc = cifs_push_locks(cfile);
3320         if (rc)
3321                 cERROR(1, "Push locks rc = %d", rc);
3322
3323         /*
3324          * releasing stale oplock after recent reconnect of smb session using
3325          * a now incorrect file handle is not a data integrity issue but do
3326          * not bother sending an oplock release if session to server still is
3327          * disconnected since oplock already released by the server
3328          */
3329         if (!cfile->oplock_break_cancelled) {
3330                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
3331                                  current->tgid, 0, 0, 0, 0,
3332                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
3333                                  cinode->clientCanCacheRead ? 1 : 0);
3334                 cFYI(1, "Oplock release rc = %d", rc);
3335         }
3336 }
3337
3338 const struct address_space_operations cifs_addr_ops = {
3339         .readpage = cifs_readpage,
3340         .readpages = cifs_readpages,
3341         .writepage = cifs_writepage,
3342         .writepages = cifs_writepages,
3343         .write_begin = cifs_write_begin,
3344         .write_end = cifs_write_end,
3345         .set_page_dirty = __set_page_dirty_nobuffers,
3346         .releasepage = cifs_release_page,
3347         .invalidatepage = cifs_invalidate_page,
3348         .launder_page = cifs_launder_page,
3349 };
3350
3351 /*
3352  * cifs_readpages requires the server to support a buffer large enough to
3353  * contain the header plus one complete page of data.  Otherwise, we need
3354  * to leave cifs_readpages out of the address space operations.
3355  */
3356 const struct address_space_operations cifs_addr_ops_smallbuf = {
3357         .readpage = cifs_readpage,
3358         .writepage = cifs_writepage,
3359         .writepages = cifs_writepages,
3360         .write_begin = cifs_write_begin,
3361         .write_end = cifs_write_end,
3362         .set_page_dirty = __set_page_dirty_nobuffers,
3363         .releasepage = cifs_release_page,
3364         .invalidatepage = cifs_invalidate_page,
3365         .launder_page = cifs_launder_page,
3366 };