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