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