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