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 <linux/mm.h>
  37 #include <asm/div64.h>
  38 #include "cifsfs.h"
  39 #include "cifspdu.h"
  40 #include "cifsglob.h"
  41 #include "cifsproto.h"
  42 #include "cifs_unicode.h"
  43 #include "cifs_debug.h"
  44 #include "cifs_fs_sb.h"
  45 #include "fscache.h"
  46 #include "smbdirect.h"
  47
  48 static inline int cifs_convert_flags(unsigned int flags)
  49 {
  50         if ((flags & O_ACCMODE) == O_RDONLY)
  51                 return GENERIC_READ;
  52         else if ((flags & O_ACCMODE) == O_WRONLY)
  53                 return GENERIC_WRITE;
  54         else if ((flags & O_ACCMODE) == O_RDWR) {
  55                 /* GENERIC_ALL is too much permission to request
  56                    can cause unnecessary access denied on create */
  57                 /* return GENERIC_ALL; */
  58                 return (GENERIC_READ | GENERIC_WRITE);
  59         }
  60
  61         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  62                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  63                 FILE_READ_DATA);
  64 }
  65
  66 static u32 cifs_posix_convert_flags(unsigned int flags)
  67 {
  68         u32 posix_flags = 0;
  69
  70         if ((flags & O_ACCMODE) == O_RDONLY)
  71                 posix_flags = SMB_O_RDONLY;
  72         else if ((flags & O_ACCMODE) == O_WRONLY)
  73                 posix_flags = SMB_O_WRONLY;
  74         else if ((flags & O_ACCMODE) == O_RDWR)
  75                 posix_flags = SMB_O_RDWR;
  76
  77         if (flags & O_CREAT) {
  78                 posix_flags |= SMB_O_CREAT;
  79                 if (flags & O_EXCL)
  80                         posix_flags |= SMB_O_EXCL;
  81         } else if (flags & O_EXCL)
  82                 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
  83                          current->comm, current->tgid);
  84
  85         if (flags & O_TRUNC)
  86                 posix_flags |= SMB_O_TRUNC;
  87         /* be safe and imply O_SYNC for O_DSYNC */
  88         if (flags & O_DSYNC)
  89                 posix_flags |= SMB_O_SYNC;
  90         if (flags & O_DIRECTORY)
  91                 posix_flags |= SMB_O_DIRECTORY;
  92         if (flags & O_NOFOLLOW)
  93                 posix_flags |= SMB_O_NOFOLLOW;
  94         if (flags & O_DIRECT)
  95                 posix_flags |= SMB_O_DIRECT;
  96
  97         return posix_flags;
  98 }
  99
 100 static inline int cifs_get_disposition(unsigned int flags)
 101 {
 102         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 103                 return FILE_CREATE;
 104         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 105                 return FILE_OVERWRITE_IF;
 106         else if ((flags & O_CREAT) == O_CREAT)
 107                 return FILE_OPEN_IF;
 108         else if ((flags & O_TRUNC) == O_TRUNC)
 109                 return FILE_OVERWRITE;
 110         else
 111                 return FILE_OPEN;
 112 }
 113
 114 int cifs_posix_open(char *full_path, struct inode **pinode,
 115                         struct super_block *sb, int mode, unsigned int f_flags,
 116                         __u32 *poplock, __u16 *pnetfid, unsigned int xid)
 117 {
 118         int rc;
 119         FILE_UNIX_BASIC_INFO *presp_data;
 120         __u32 posix_flags = 0;
 121         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 122         struct cifs_fattr fattr;
 123         struct tcon_link *tlink;
 124         struct cifs_tcon *tcon;
 125
 126         cifs_dbg(FYI, "posix open %s\n", full_path);
 127
 128         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 129         if (presp_data == NULL)
 130                 return -ENOMEM;
 131
 132         tlink = cifs_sb_tlink(cifs_sb);
 133         if (IS_ERR(tlink)) {
 134                 rc = PTR_ERR(tlink);
 135                 goto posix_open_ret;
 136         }
 137
 138         tcon = tlink_tcon(tlink);
 139         mode &= ~current_umask();
 140
 141         posix_flags = cifs_posix_convert_flags(f_flags);
 142         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 143                              poplock, full_path, cifs_sb->local_nls,
 144                              cifs_remap(cifs_sb));
 145         cifs_put_tlink(tlink);
 146
 147         if (rc)
 148                 goto posix_open_ret;
 149
 150         if (presp_data->Type == cpu_to_le32(-1))
 151                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 152
 153         if (!pinode)
 154                 goto posix_open_ret; /* caller does not need info */
 155
 156         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 157
 158         /* get new inode and set it up */
 159         if (*pinode == NULL) {
 160                 cifs_fill_uniqueid(sb, &fattr);
 161                 *pinode = cifs_iget(sb, &fattr);
 162                 if (!*pinode) {
 163                         rc = -ENOMEM;
 164                         goto posix_open_ret;
 165                 }
 166         } else {
 167                 cifs_fattr_to_inode(*pinode, &fattr);
 168         }
 169
 170 posix_open_ret:
 171         kfree(presp_data);
 172         return rc;
 173 }
 174
 175 static int
 176 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 177              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
 178              struct cifs_fid *fid, unsigned int xid)
 179 {
 180         int rc;
 181         int desired_access;
 182         int disposition;
 183         int create_options = CREATE_NOT_DIR;
 184         FILE_ALL_INFO *buf;
 185         struct TCP_Server_Info *server = tcon->ses->server;
 186         struct cifs_open_parms oparms;
 187
 188         if (!server->ops->open)
 189                 return -ENOSYS;
 190
 191         desired_access = cifs_convert_flags(f_flags);
 192
 193 /*********************************************************************
 194  *  open flag mapping table:
 195  *
 196  *      POSIX Flag            CIFS Disposition
 197  *      ----------            ----------------
 198  *      O_CREAT               FILE_OPEN_IF
 199  *      O_CREAT | O_EXCL      FILE_CREATE
 200  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 201  *      O_TRUNC               FILE_OVERWRITE
 202  *      none of the above     FILE_OPEN
 203  *
 204  *      Note that there is not a direct match between disposition
 205  *      FILE_SUPERSEDE (ie create whether or not file exists although
 206  *      O_CREAT | O_TRUNC is similar but truncates the existing
 207  *      file rather than creating a new file as FILE_SUPERSEDE does
 208  *      (which uses the attributes / metadata passed in on open call)
 209  *?
 210  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 211  *?  and the read write flags match reasonably.  O_LARGEFILE
 212  *?  is irrelevant because largefile support is always used
 213  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 214  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 215  *********************************************************************/
 216
 217         disposition = cifs_get_disposition(f_flags);
 218
 219         /* BB pass O_SYNC flag through on file attributes .. BB */
 220
 221         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 222         if (!buf)
 223                 return -ENOMEM;
 224
 225         /* O_SYNC also has bit for O_DSYNC so following check picks up either */
 226         if (f_flags & O_SYNC)
 227                 create_options |= CREATE_WRITE_THROUGH;
 228
 229         if (f_flags & O_DIRECT)
 230                 create_options |= CREATE_NO_BUFFER;
 231
 232         oparms.tcon = tcon;
 233         oparms.cifs_sb = cifs_sb;
 234         oparms.desired_access = desired_access;
 235         oparms.create_options = cifs_create_options(cifs_sb, create_options);
 236         oparms.disposition = disposition;
 237         oparms.path = full_path;
 238         oparms.fid = fid;
 239         oparms.reconnect = false;
 240
 241         rc = server->ops->open(xid, &oparms, oplock, buf);
 242
 243         if (rc)
 244                 goto out;
 245
 246         if (tcon->unix_ext)
 247                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 248                                               xid);
 249         else
 250                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 251                                          xid, fid);
 252
 253         if (rc) {
 254                 server->ops->close(xid, tcon, fid);
 255                 if (rc == -ESTALE)
 256                         rc = -EOPENSTALE;
 257         }
 258
 259 out:
 260         kfree(buf);
 261         return rc;
 262 }
 263
 264 static bool
 265 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
 266 {
 267         struct cifs_fid_locks *cur;
 268         bool has_locks = false;
 269
 270         down_read(&cinode->lock_sem);
 271         list_for_each_entry(cur, &cinode->llist, llist) {
 272                 if (!list_empty(&cur->locks)) {
 273                         has_locks = true;
 274                         break;
 275                 }
 276         }
 277         up_read(&cinode->lock_sem);
 278         return has_locks;
 279 }
 280
 281 void
 282 cifs_down_write(struct rw_semaphore *sem)
 283 {
 284         while (!down_write_trylock(sem))
 285                 msleep(10);
 286 }
 287
 288 static void cifsFileInfo_put_work(struct work_struct *work);
 289
 290 struct cifsFileInfo *
 291 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
 292                   struct tcon_link *tlink, __u32 oplock)
 293 {
 294         struct dentry *dentry = file_dentry(file);
 295         struct inode *inode = d_inode(dentry);
 296         struct cifsInodeInfo *cinode = CIFS_I(inode);
 297         struct cifsFileInfo *cfile;
 298         struct cifs_fid_locks *fdlocks;
 299         struct cifs_tcon *tcon = tlink_tcon(tlink);
 300         struct TCP_Server_Info *server = tcon->ses->server;
 301
 302         cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 303         if (cfile == NULL)
 304                 return cfile;
 305
 306         fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
 307         if (!fdlocks) {
 308                 kfree(cfile);
 309                 return NULL;
 310         }
 311
 312         INIT_LIST_HEAD(&fdlocks->locks);
 313         fdlocks->cfile = cfile;
 314         cfile->llist = fdlocks;
 315
 316         cfile->count = 1;
 317         cfile->pid = current->tgid;
 318         cfile->uid = current_fsuid();
 319         cfile->dentry = dget(dentry);
 320         cfile->f_flags = file->f_flags;
 321         cfile->invalidHandle = false;
 322         cfile->tlink = cifs_get_tlink(tlink);
 323         INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
 324         INIT_WORK(&cfile->put, cifsFileInfo_put_work);
 325         mutex_init(&cfile->fh_mutex);
 326         spin_lock_init(&cfile->file_info_lock);
 327
 328         cifs_sb_active(inode->i_sb);
 329
 330         /*
 331          * If the server returned a read oplock and we have mandatory brlocks,
 332          * set oplock level to None.
 333          */
 334         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 335                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 336                 oplock = 0;
 337         }
 338
 339         cifs_down_write(&cinode->lock_sem);
 340         list_add(&fdlocks->llist, &cinode->llist);
 341         up_write(&cinode->lock_sem);
 342
 343         spin_lock(&tcon->open_file_lock);
 344         if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
 345                 oplock = fid->pending_open->oplock;
 346         list_del(&fid->pending_open->olist);
 347
 348         fid->purge_cache = false;
 349         server->ops->set_fid(cfile, fid, oplock);
 350
 351         list_add(&cfile->tlist, &tcon->openFileList);
 352         atomic_inc(&tcon->num_local_opens);
 353
 354         /* if readable file instance put first in list*/
 355         spin_lock(&cinode->open_file_lock);
 356         if (file->f_mode & FMODE_READ)
 357                 list_add(&cfile->flist, &cinode->openFileList);
 358         else
 359                 list_add_tail(&cfile->flist, &cinode->openFileList);
 360         spin_unlock(&cinode->open_file_lock);
 361         spin_unlock(&tcon->open_file_lock);
 362
 363         if (fid->purge_cache)
 364                 cifs_zap_mapping(inode);
 365
 366         file->private_data = cfile;
 367         return cfile;
 368 }
 369
 370 struct cifsFileInfo *
 371 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 372 {
 373         spin_lock(&cifs_file->file_info_lock);
 374         cifsFileInfo_get_locked(cifs_file);
 375         spin_unlock(&cifs_file->file_info_lock);
 376         return cifs_file;
 377 }
 378
 379 static void cifsFileInfo_put_final(struct cifsFileInfo *cifs_file)
 380 {
 381         struct inode *inode = d_inode(cifs_file->dentry);
 382         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 383         struct cifsLockInfo *li, *tmp;
 384         struct super_block *sb = inode->i_sb;
 385
 386         /*
 387          * Delete any outstanding lock records. We'll lose them when the file
 388          * is closed anyway.
 389          */
 390         cifs_down_write(&cifsi->lock_sem);
 391         list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
 392                 list_del(&li->llist);
 393                 cifs_del_lock_waiters(li);
 394                 kfree(li);
 395         }
 396         list_del(&cifs_file->llist->llist);
 397         kfree(cifs_file->llist);
 398         up_write(&cifsi->lock_sem);
 399
 400         cifs_put_tlink(cifs_file->tlink);
 401         dput(cifs_file->dentry);
 402         cifs_sb_deactive(sb);
 403         kfree(cifs_file);
 404 }
 405
 406 static void cifsFileInfo_put_work(struct work_struct *work)
 407 {
 408         struct cifsFileInfo *cifs_file = container_of(work,
 409                         struct cifsFileInfo, put);
 410
 411         cifsFileInfo_put_final(cifs_file);
 412 }
 413
 414 /**
 415  * cifsFileInfo_put - release a reference of file priv data
 416  *
 417  * Always potentially wait for oplock handler. See _cifsFileInfo_put().
 418  */
 419 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 420 {
 421         _cifsFileInfo_put(cifs_file, true, true);
 422 }
 423
 424 /**
 425  * _cifsFileInfo_put - release a reference of file priv data
 426  *
 427  * This may involve closing the filehandle @cifs_file out on the
 428  * server. Must be called without holding tcon->open_file_lock,
 429  * cinode->open_file_lock and cifs_file->file_info_lock.
 430  *
 431  * If @wait_for_oplock_handler is true and we are releasing the last
 432  * reference, wait for any running oplock break handler of the file
 433  * and cancel any pending one. If calling this function from the
 434  * oplock break handler, you need to pass false.
 435  *
 436  */
 437 void _cifsFileInfo_put(struct cifsFileInfo *cifs_file,
 438                        bool wait_oplock_handler, bool offload)
 439 {
 440         struct inode *inode = d_inode(cifs_file->dentry);
 441         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 442         struct TCP_Server_Info *server = tcon->ses->server;
 443         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 444         struct super_block *sb = inode->i_sb;
 445         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 446         struct cifs_fid fid;
 447         struct cifs_pending_open open;
 448         bool oplock_break_cancelled;
 449
 450         spin_lock(&tcon->open_file_lock);
 451         spin_lock(&cifsi->open_file_lock);
 452         spin_lock(&cifs_file->file_info_lock);
 453         if (--cifs_file->count > 0) {
 454                 spin_unlock(&cifs_file->file_info_lock);
 455                 spin_unlock(&cifsi->open_file_lock);
 456                 spin_unlock(&tcon->open_file_lock);
 457                 return;
 458         }
 459         spin_unlock(&cifs_file->file_info_lock);
 460
 461         if (server->ops->get_lease_key)
 462                 server->ops->get_lease_key(inode, &fid);
 463
 464         /* store open in pending opens to make sure we don't miss lease break */
 465         cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
 466
 467         /* remove it from the lists */
 468         list_del(&cifs_file->flist);
 469         list_del(&cifs_file->tlist);
 470         atomic_dec(&tcon->num_local_opens);
 471
 472         if (list_empty(&cifsi->openFileList)) {
 473                 cifs_dbg(FYI, "closing last open instance for inode %p\n",
 474                          d_inode(cifs_file->dentry));
 475                 /*
 476                  * In strict cache mode we need invalidate mapping on the last
 477                  * close  because it may cause a error when we open this file
 478                  * again and get at least level II oplock.
 479                  */
 480                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 481                         set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
 482                 cifs_set_oplock_level(cifsi, 0);
 483         }
 484
 485         spin_unlock(&cifsi->open_file_lock);
 486         spin_unlock(&tcon->open_file_lock);
 487
 488         oplock_break_cancelled = wait_oplock_handler ?
 489                 cancel_work_sync(&cifs_file->oplock_break) : false;
 490
 491         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 492                 struct TCP_Server_Info *server = tcon->ses->server;
 493                 unsigned int xid;
 494
 495                 xid = get_xid();
 496                 if (server->ops->close_getattr)
 497                         server->ops->close_getattr(xid, tcon, cifs_file);
 498                 else if (server->ops->close)
 499                         server->ops->close(xid, tcon, &cifs_file->fid);
 500                 _free_xid(xid);
 501         }
 502
 503         if (oplock_break_cancelled)
 504                 cifs_done_oplock_break(cifsi);
 505
 506         cifs_del_pending_open(&open);
 507
 508         if (offload)
 509                 queue_work(fileinfo_put_wq, &cifs_file->put);
 510         else
 511                 cifsFileInfo_put_final(cifs_file);
 512 }
 513
 514 int cifs_open(struct inode *inode, struct file *file)
 515
 516 {
 517         int rc = -EACCES;
 518         unsigned int xid;
 519         __u32 oplock;
 520         struct cifs_sb_info *cifs_sb;
 521         struct TCP_Server_Info *server;
 522         struct cifs_tcon *tcon;
 523         struct tcon_link *tlink;
 524         struct cifsFileInfo *cfile = NULL;
 525         char *full_path = NULL;
 526         bool posix_open_ok = false;
 527         struct cifs_fid fid;
 528         struct cifs_pending_open open;
 529
 530         xid = get_xid();
 531
 532         cifs_sb = CIFS_SB(inode->i_sb);
 533         tlink = cifs_sb_tlink(cifs_sb);
 534         if (IS_ERR(tlink)) {
 535                 free_xid(xid);
 536                 return PTR_ERR(tlink);
 537         }
 538         tcon = tlink_tcon(tlink);
 539         server = tcon->ses->server;
 540
 541         full_path = build_path_from_dentry(file_dentry(file));
 542         if (full_path == NULL) {
 543                 rc = -ENOMEM;
 544                 goto out;
 545         }
 546
 547         cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
 548                  inode, file->f_flags, full_path);
 549
 550         if (file->f_flags & O_DIRECT &&
 551             cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 552                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 553                         file->f_op = &cifs_file_direct_nobrl_ops;
 554                 else
 555                         file->f_op = &cifs_file_direct_ops;
 556         }
 557
 558         if (server->oplocks)
 559                 oplock = REQ_OPLOCK;
 560         else
 561                 oplock = 0;
 562
 563         if (!tcon->broken_posix_open && tcon->unix_ext &&
 564             cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 565                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 566                 /* can not refresh inode info since size could be stale */
 567                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 568                                 cifs_sb->mnt_file_mode /* ignored */,
 569                                 file->f_flags, &oplock, &fid.netfid, xid);
 570                 if (rc == 0) {
 571                         cifs_dbg(FYI, "posix open succeeded\n");
 572                         posix_open_ok = true;
 573                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 574                         if (tcon->ses->serverNOS)
 575                                 cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
 576                                          tcon->ses->serverName,
 577                                          tcon->ses->serverNOS);
 578                         tcon->broken_posix_open = true;
 579                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 580                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 581                         goto out;
 582                 /*
 583                  * Else fallthrough to retry open the old way on network i/o
 584                  * or DFS errors.
 585                  */
 586         }
 587
 588         if (server->ops->get_lease_key)
 589                 server->ops->get_lease_key(inode, &fid);
 590
 591         cifs_add_pending_open(&fid, tlink, &open);
 592
 593         if (!posix_open_ok) {
 594                 if (server->ops->get_lease_key)
 595                         server->ops->get_lease_key(inode, &fid);
 596
 597                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 598                                   file->f_flags, &oplock, &fid, xid);
 599                 if (rc) {
 600                         cifs_del_pending_open(&open);
 601                         goto out;
 602                 }
 603         }
 604
 605         cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
 606         if (cfile == NULL) {
 607                 if (server->ops->close)
 608                         server->ops->close(xid, tcon, &fid);
 609                 cifs_del_pending_open(&open);
 610                 rc = -ENOMEM;
 611                 goto out;
 612         }
 613
 614         cifs_fscache_set_inode_cookie(inode, file);
 615
 616         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 617                 /*
 618                  * Time to set mode which we can not set earlier due to
 619                  * problems creating new read-only files.
 620                  */
 621                 struct cifs_unix_set_info_args args = {
 622                         .mode   = inode->i_mode,
 623                         .uid    = INVALID_UID, /* no change */
 624                         .gid    = INVALID_GID, /* no change */
 625                         .ctime  = NO_CHANGE_64,
 626                         .atime  = NO_CHANGE_64,
 627                         .mtime  = NO_CHANGE_64,
 628                         .device = 0,
 629                 };
 630                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
 631                                        cfile->pid);
 632         }
 633
 634 out:
 635         kfree(full_path);
 636         free_xid(xid);
 637         cifs_put_tlink(tlink);
 638         return rc;
 639 }
 640
 641 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
 642
 643 /*
 644  * Try to reacquire byte range locks that were released when session
 645  * to server was lost.
 646  */
 647 static int
 648 cifs_relock_file(struct cifsFileInfo *cfile)
 649 {
 650         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
 651         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 652         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 653         int rc = 0;
 654
 655         down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
 656         if (cinode->can_cache_brlcks) {
 657                 /* can cache locks - no need to relock */
 658                 up_read(&cinode->lock_sem);
 659                 return rc;
 660         }
 661
 662         if (cap_unix(tcon->ses) &&
 663             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 664             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 665                 rc = cifs_push_posix_locks(cfile);
 666         else
 667                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
 668
 669         up_read(&cinode->lock_sem);
 670         return rc;
 671 }
 672
 673 static int
 674 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
 675 {
 676         int rc = -EACCES;
 677         unsigned int xid;
 678         __u32 oplock;
 679         struct cifs_sb_info *cifs_sb;
 680         struct cifs_tcon *tcon;
 681         struct TCP_Server_Info *server;
 682         struct cifsInodeInfo *cinode;
 683         struct inode *inode;
 684         char *full_path = NULL;
 685         int desired_access;
 686         int disposition = FILE_OPEN;
 687         int create_options = CREATE_NOT_DIR;
 688         struct cifs_open_parms oparms;
 689
 690         xid = get_xid();
 691         mutex_lock(&cfile->fh_mutex);
 692         if (!cfile->invalidHandle) {
 693                 mutex_unlock(&cfile->fh_mutex);
 694                 rc = 0;
 695                 free_xid(xid);
 696                 return rc;
 697         }
 698
 699         inode = d_inode(cfile->dentry);
 700         cifs_sb = CIFS_SB(inode->i_sb);
 701         tcon = tlink_tcon(cfile->tlink);
 702         server = tcon->ses->server;
 703
 704         /*
 705          * Can not grab rename sem here because various ops, including those
 706          * that already have the rename sem can end up causing writepage to get
 707          * called and if the server was down that means we end up here, and we
 708          * can never tell if the caller already has the rename_sem.
 709          */
 710         full_path = build_path_from_dentry(cfile->dentry);
 711         if (full_path == NULL) {
 712                 rc = -ENOMEM;
 713                 mutex_unlock(&cfile->fh_mutex);
 714                 free_xid(xid);
 715                 return rc;
 716         }
 717
 718         cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
 719                  inode, cfile->f_flags, full_path);
 720
 721         if (tcon->ses->server->oplocks)
 722                 oplock = REQ_OPLOCK;
 723         else
 724                 oplock = 0;
 725
 726         if (tcon->unix_ext && cap_unix(tcon->ses) &&
 727             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 728                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 729                 /*
 730                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 731                  * original open. Must mask them off for a reopen.
 732                  */
 733                 unsigned int oflags = cfile->f_flags &
 734                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 735
 736                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 737                                      cifs_sb->mnt_file_mode /* ignored */,
 738                                      oflags, &oplock, &cfile->fid.netfid, xid);
 739                 if (rc == 0) {
 740                         cifs_dbg(FYI, "posix reopen succeeded\n");
 741                         oparms.reconnect = true;
 742                         goto reopen_success;
 743                 }
 744                 /*
 745                  * fallthrough to retry open the old way on errors, especially
 746                  * in the reconnect path it is important to retry hard
 747                  */
 748         }
 749
 750         desired_access = cifs_convert_flags(cfile->f_flags);
 751
 752         /* O_SYNC also has bit for O_DSYNC so following check picks up either */
 753         if (cfile->f_flags & O_SYNC)
 754                 create_options |= CREATE_WRITE_THROUGH;
 755
 756         if (cfile->f_flags & O_DIRECT)
 757                 create_options |= CREATE_NO_BUFFER;
 758
 759         if (server->ops->get_lease_key)
 760                 server->ops->get_lease_key(inode, &cfile->fid);
 761
 762         oparms.tcon = tcon;
 763         oparms.cifs_sb = cifs_sb;
 764         oparms.desired_access = desired_access;
 765         oparms.create_options = cifs_create_options(cifs_sb, create_options);
 766         oparms.disposition = disposition;
 767         oparms.path = full_path;
 768         oparms.fid = &cfile->fid;
 769         oparms.reconnect = true;
 770
 771         /*
 772          * Can not refresh inode by passing in file_info buf to be returned by
 773          * ops->open and then calling get_inode_info with returned buf since
 774          * file might have write behind data that needs to be flushed and server
 775          * version of file size can be stale. If we knew for sure that inode was
 776          * not dirty locally we could do this.
 777          */
 778         rc = server->ops->open(xid, &oparms, &oplock, NULL);
 779         if (rc == -ENOENT && oparms.reconnect == false) {
 780                 /* durable handle timeout is expired - open the file again */
 781                 rc = server->ops->open(xid, &oparms, &oplock, NULL);
 782                 /* indicate that we need to relock the file */
 783                 oparms.reconnect = true;
 784         }
 785
 786         if (rc) {
 787                 mutex_unlock(&cfile->fh_mutex);
 788                 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
 789                 cifs_dbg(FYI, "oplock: %d\n", oplock);
 790                 goto reopen_error_exit;
 791         }
 792
 793 reopen_success:
 794         cfile->invalidHandle = false;
 795         mutex_unlock(&cfile->fh_mutex);
 796         cinode = CIFS_I(inode);
 797
 798         if (can_flush) {
 799                 rc = filemap_write_and_wait(inode->i_mapping);
 800                 if (!is_interrupt_error(rc))
 801                         mapping_set_error(inode->i_mapping, rc);
 802
 803                 if (tcon->unix_ext)
 804                         rc = cifs_get_inode_info_unix(&inode, full_path,
 805                                                       inode->i_sb, xid);
 806                 else
 807                         rc = cifs_get_inode_info(&inode, full_path, NULL,
 808                                                  inode->i_sb, xid, NULL);
 809         }
 810         /*
 811          * Else we are writing out data to server already and could deadlock if
 812          * we tried to flush data, and since we do not know if we have data that
 813          * would invalidate the current end of file on the server we can not go
 814          * to the server to get the new inode info.
 815          */
 816
 817         /*
 818          * If the server returned a read oplock and we have mandatory brlocks,
 819          * set oplock level to None.
 820          */
 821         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 822                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 823                 oplock = 0;
 824         }
 825
 826         server->ops->set_fid(cfile, &cfile->fid, oplock);
 827         if (oparms.reconnect)
 828                 cifs_relock_file(cfile);
 829
 830 reopen_error_exit:
 831         kfree(full_path);
 832         free_xid(xid);
 833         return rc;
 834 }
 835
 836 int cifs_close(struct inode *inode, struct file *file)
 837 {
 838         if (file->private_data != NULL) {
 839                 _cifsFileInfo_put(file->private_data, true, false);
 840                 file->private_data = NULL;
 841         }
 842
 843         /* return code from the ->release op is always ignored */
 844         return 0;
 845 }
 846
 847 void
 848 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
 849 {
 850         struct cifsFileInfo *open_file;
 851         struct list_head *tmp;
 852         struct list_head *tmp1;
 853         struct list_head tmp_list;
 854
 855         if (!tcon->use_persistent || !tcon->need_reopen_files)
 856                 return;
 857
 858         tcon->need_reopen_files = false;
 859
 860         cifs_dbg(FYI, "Reopen persistent handles");
 861         INIT_LIST_HEAD(&tmp_list);
 862
 863         /* list all files open on tree connection, reopen resilient handles  */
 864         spin_lock(&tcon->open_file_lock);
 865         list_for_each(tmp, &tcon->openFileList) {
 866                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
 867                 if (!open_file->invalidHandle)
 868                         continue;
 869                 cifsFileInfo_get(open_file);
 870                 list_add_tail(&open_file->rlist, &tmp_list);
 871         }
 872         spin_unlock(&tcon->open_file_lock);
 873
 874         list_for_each_safe(tmp, tmp1, &tmp_list) {
 875                 open_file = list_entry(tmp, struct cifsFileInfo, rlist);
 876                 if (cifs_reopen_file(open_file, false /* do not flush */))
 877                         tcon->need_reopen_files = true;
 878                 list_del_init(&open_file->rlist);
 879                 cifsFileInfo_put(open_file);
 880         }
 881 }
 882
 883 int cifs_closedir(struct inode *inode, struct file *file)
 884 {
 885         int rc = 0;
 886         unsigned int xid;
 887         struct cifsFileInfo *cfile = file->private_data;
 888         struct cifs_tcon *tcon;
 889         struct TCP_Server_Info *server;
 890         char *buf;
 891
 892         cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
 893
 894         if (cfile == NULL)
 895                 return rc;
 896
 897         xid = get_xid();
 898         tcon = tlink_tcon(cfile->tlink);
 899         server = tcon->ses->server;
 900
 901         cifs_dbg(FYI, "Freeing private data in close dir\n");
 902         spin_lock(&cfile->file_info_lock);
 903         if (server->ops->dir_needs_close(cfile)) {
 904                 cfile->invalidHandle = true;
 905                 spin_unlock(&cfile->file_info_lock);
 906                 if (server->ops->close_dir)
 907                         rc = server->ops->close_dir(xid, tcon, &cfile->fid);
 908                 else
 909                         rc = -ENOSYS;
 910                 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
 911                 /* not much we can do if it fails anyway, ignore rc */
 912                 rc = 0;
 913         } else
 914                 spin_unlock(&cfile->file_info_lock);
 915
 916         buf = cfile->srch_inf.ntwrk_buf_start;
 917         if (buf) {
 918                 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
 919                 cfile->srch_inf.ntwrk_buf_start = NULL;
 920                 if (cfile->srch_inf.smallBuf)
 921                         cifs_small_buf_release(buf);
 922                 else
 923                         cifs_buf_release(buf);
 924         }
 925
 926         cifs_put_tlink(cfile->tlink);
 927         kfree(file->private_data);
 928         file->private_data = NULL;
 929         /* BB can we lock the filestruct while this is going on? */
 930         free_xid(xid);
 931         return rc;
 932 }
 933
 934 static struct cifsLockInfo *
 935 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
 936 {
 937         struct cifsLockInfo *lock =
 938                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 939         if (!lock)
 940                 return lock;
 941         lock->offset = offset;
 942         lock->length = length;
 943         lock->type = type;
 944         lock->pid = current->tgid;
 945         lock->flags = flags;
 946         INIT_LIST_HEAD(&lock->blist);
 947         init_waitqueue_head(&lock->block_q);
 948         return lock;
 949 }
 950
 951 void
 952 cifs_del_lock_waiters(struct cifsLockInfo *lock)
 953 {
 954         struct cifsLockInfo *li, *tmp;
 955         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
 956                 list_del_init(&li->blist);
 957                 wake_up(&li->block_q);
 958         }
 959 }
 960
 961 #define CIFS_LOCK_OP    0
 962 #define CIFS_READ_OP    1
 963 #define CIFS_WRITE_OP   2
 964
 965 /* @rw_check : 0 - no op, 1 - read, 2 - write */
 966 static bool
 967 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
 968                             __u64 length, __u8 type, __u16 flags,
 969                             struct cifsFileInfo *cfile,
 970                             struct cifsLockInfo **conf_lock, int rw_check)
 971 {
 972         struct cifsLockInfo *li;
 973         struct cifsFileInfo *cur_cfile = fdlocks->cfile;
 974         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 975
 976         list_for_each_entry(li, &fdlocks->locks, llist) {
 977                 if (offset + length <= li->offset ||
 978                     offset >= li->offset + li->length)
 979                         continue;
 980                 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
 981                     server->ops->compare_fids(cfile, cur_cfile)) {
 982                         /* shared lock prevents write op through the same fid */
 983                         if (!(li->type & server->vals->shared_lock_type) ||
 984                             rw_check != CIFS_WRITE_OP)
 985                                 continue;
 986                 }
 987                 if ((type & server->vals->shared_lock_type) &&
 988                     ((server->ops->compare_fids(cfile, cur_cfile) &&
 989                      current->tgid == li->pid) || type == li->type))
 990                         continue;
 991                 if (rw_check == CIFS_LOCK_OP &&
 992                     (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
 993                     server->ops->compare_fids(cfile, cur_cfile))
 994                         continue;
 995                 if (conf_lock)
 996                         *conf_lock = li;
 997                 return true;
 998         }
 999         return false;
1000 }
1001
1002 bool
1003 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1004                         __u8 type, __u16 flags,
1005                         struct cifsLockInfo **conf_lock, int rw_check)
1006 {
1007         bool rc = false;
1008         struct cifs_fid_locks *cur;
1009         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1010
1011         list_for_each_entry(cur, &cinode->llist, llist) {
1012                 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
1013                                                  flags, cfile, conf_lock,
1014                                                  rw_check);
1015                 if (rc)
1016                         break;
1017         }
1018
1019         return rc;
1020 }
1021
1022 /*
1023  * Check if there is another lock that prevents us to set the lock (mandatory
1024  * style). If such a lock exists, update the flock structure with its
1025  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1026  * or leave it the same if we can't. Returns 0 if we don't need to request to
1027  * the server or 1 otherwise.
1028  */
1029 static int
1030 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1031                __u8 type, struct file_lock *flock)
1032 {
1033         int rc = 0;
1034         struct cifsLockInfo *conf_lock;
1035         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1036         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1037         bool exist;
1038
1039         down_read(&cinode->lock_sem);
1040
1041         exist = cifs_find_lock_conflict(cfile, offset, length, type,
1042                                         flock->fl_flags, &conf_lock,
1043                                         CIFS_LOCK_OP);
1044         if (exist) {
1045                 flock->fl_start = conf_lock->offset;
1046                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1047                 flock->fl_pid = conf_lock->pid;
1048                 if (conf_lock->type & server->vals->shared_lock_type)
1049                         flock->fl_type = F_RDLCK;
1050                 else
1051                         flock->fl_type = F_WRLCK;
1052         } else if (!cinode->can_cache_brlcks)
1053                 rc = 1;
1054         else
1055                 flock->fl_type = F_UNLCK;
1056
1057         up_read(&cinode->lock_sem);
1058         return rc;
1059 }
1060
1061 static void
1062 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1063 {
1064         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1065         cifs_down_write(&cinode->lock_sem);
1066         list_add_tail(&lock->llist, &cfile->llist->locks);
1067         up_write(&cinode->lock_sem);
1068 }
1069
1070 /*
1071  * Set the byte-range lock (mandatory style). Returns:
1072  * 1) 0, if we set the lock and don't need to request to the server;
1073  * 2) 1, if no locks prevent us but we need to request to the server;
1074  * 3) -EACCES, if there is a lock that prevents us and wait is false.
1075  */
1076 static int
1077 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1078                  bool wait)
1079 {
1080         struct cifsLockInfo *conf_lock;
1081         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1082         bool exist;
1083         int rc = 0;
1084
1085 try_again:
1086         exist = false;
1087         cifs_down_write(&cinode->lock_sem);
1088
1089         exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1090                                         lock->type, lock->flags, &conf_lock,
1091                                         CIFS_LOCK_OP);
1092         if (!exist && cinode->can_cache_brlcks) {
1093                 list_add_tail(&lock->llist, &cfile->llist->locks);
1094                 up_write(&cinode->lock_sem);
1095                 return rc;
1096         }
1097
1098         if (!exist)
1099                 rc = 1;
1100         else if (!wait)
1101                 rc = -EACCES;
1102         else {
1103                 list_add_tail(&lock->blist, &conf_lock->blist);
1104                 up_write(&cinode->lock_sem);
1105                 rc = wait_event_interruptible(lock->block_q,
1106                                         (lock->blist.prev == &lock->blist) &&
1107                                         (lock->blist.next == &lock->blist));
1108                 if (!rc)
1109                         goto try_again;
1110                 cifs_down_write(&cinode->lock_sem);
1111                 list_del_init(&lock->blist);
1112         }
1113
1114         up_write(&cinode->lock_sem);
1115         return rc;
1116 }
1117
1118 /*
1119  * Check if there is another lock that prevents us to set the lock (posix
1120  * style). If such a lock exists, update the flock structure with its
1121  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1122  * or leave it the same if we can't. Returns 0 if we don't need to request to
1123  * the server or 1 otherwise.
1124  */
1125 static int
1126 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1127 {
1128         int rc = 0;
1129         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1130         unsigned char saved_type = flock->fl_type;
1131
1132         if ((flock->fl_flags & FL_POSIX) == 0)
1133                 return 1;
1134
1135         down_read(&cinode->lock_sem);
1136         posix_test_lock(file, flock);
1137
1138         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1139                 flock->fl_type = saved_type;
1140                 rc = 1;
1141         }
1142
1143         up_read(&cinode->lock_sem);
1144         return rc;
1145 }
1146
1147 /*
1148  * Set the byte-range lock (posix style). Returns:
1149  * 1) 0, if we set the lock and don't need to request to the server;
1150  * 2) 1, if we need to request to the server;
1151  * 3) <0, if the error occurs while setting the lock.
1152  */
1153 static int
1154 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1155 {
1156         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1157         int rc = 1;
1158
1159         if ((flock->fl_flags & FL_POSIX) == 0)
1160                 return rc;
1161
1162 try_again:
1163         cifs_down_write(&cinode->lock_sem);
1164         if (!cinode->can_cache_brlcks) {
1165                 up_write(&cinode->lock_sem);
1166                 return rc;
1167         }
1168
1169         rc = posix_lock_file(file, flock, NULL);
1170         up_write(&cinode->lock_sem);
1171         if (rc == FILE_LOCK_DEFERRED) {
1172                 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_blocker);
1173                 if (!rc)
1174                         goto try_again;
1175                 locks_delete_block(flock);
1176         }
1177         return rc;
1178 }
1179
1180 int
1181 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1182 {
1183         unsigned int xid;
1184         int rc = 0, stored_rc;
1185         struct cifsLockInfo *li, *tmp;
1186         struct cifs_tcon *tcon;
1187         unsigned int num, max_num, max_buf;
1188         LOCKING_ANDX_RANGE *buf, *cur;
1189         static const int types[] = {
1190                 LOCKING_ANDX_LARGE_FILES,
1191                 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1192         };
1193         int i;
1194
1195         xid = get_xid();
1196         tcon = tlink_tcon(cfile->tlink);
1197
1198         /*
1199          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1200          * and check it before using.
1201          */
1202         max_buf = tcon->ses->server->maxBuf;
1203         if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1204                 free_xid(xid);
1205                 return -EINVAL;
1206         }
1207
1208         BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1209                      PAGE_SIZE);
1210         max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1211                         PAGE_SIZE);
1212         max_num = (max_buf - sizeof(struct smb_hdr)) /
1213                                                 sizeof(LOCKING_ANDX_RANGE);
1214         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1215         if (!buf) {
1216                 free_xid(xid);
1217                 return -ENOMEM;
1218         }
1219
1220         for (i = 0; i < 2; i++) {
1221                 cur = buf;
1222                 num = 0;
1223                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1224                         if (li->type != types[i])
1225                                 continue;
1226                         cur->Pid = cpu_to_le16(li->pid);
1227                         cur->LengthLow = cpu_to_le32((u32)li->length);
1228                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1229                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1230                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1231                         if (++num == max_num) {
1232                                 stored_rc = cifs_lockv(xid, tcon,
1233                                                        cfile->fid.netfid,
1234                                                        (__u8)li->type, 0, num,
1235                                                        buf);
1236                                 if (stored_rc)
1237                                         rc = stored_rc;
1238                                 cur = buf;
1239                                 num = 0;
1240                         } else
1241                                 cur++;
1242                 }
1243
1244                 if (num) {
1245                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1246                                                (__u8)types[i], 0, num, buf);
1247                         if (stored_rc)
1248                                 rc = stored_rc;
1249                 }
1250         }
1251
1252         kfree(buf);
1253         free_xid(xid);
1254         return rc;
1255 }
1256
1257 static __u32
1258 hash_lockowner(fl_owner_t owner)
1259 {
1260         return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1261 }
1262
1263 struct lock_to_push {
1264         struct list_head llist;
1265         __u64 offset;
1266         __u64 length;
1267         __u32 pid;
1268         __u16 netfid;
1269         __u8 type;
1270 };
1271
1272 static int
1273 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1274 {
1275         struct inode *inode = d_inode(cfile->dentry);
1276         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1277         struct file_lock *flock;
1278         struct file_lock_context *flctx = inode->i_flctx;
1279         unsigned int count = 0, i;
1280         int rc = 0, xid, type;
1281         struct list_head locks_to_send, *el;
1282         struct lock_to_push *lck, *tmp;
1283         __u64 length;
1284
1285         xid = get_xid();
1286
1287         if (!flctx)
1288                 goto out;
1289
1290         spin_lock(&flctx->flc_lock);
1291         list_for_each(el, &flctx->flc_posix) {
1292                 count++;
1293         }
1294         spin_unlock(&flctx->flc_lock);
1295
1296         INIT_LIST_HEAD(&locks_to_send);
1297
1298         /*
1299          * Allocating count locks is enough because no FL_POSIX locks can be
1300          * added to the list while we are holding cinode->lock_sem that
1301          * protects locking operations of this inode.
1302          */
1303         for (i = 0; i < count; i++) {
1304                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1305                 if (!lck) {
1306                         rc = -ENOMEM;
1307                         goto err_out;
1308                 }
1309                 list_add_tail(&lck->llist, &locks_to_send);
1310         }
1311
1312         el = locks_to_send.next;
1313         spin_lock(&flctx->flc_lock);
1314         list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1315                 if (el == &locks_to_send) {
1316                         /*
1317                          * The list ended. We don't have enough allocated
1318                          * structures - something is really wrong.
1319                          */
1320                         cifs_dbg(VFS, "Can't push all brlocks!\n");
1321                         break;
1322                 }
1323                 length = 1 + flock->fl_end - flock->fl_start;
1324                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1325                         type = CIFS_RDLCK;
1326                 else
1327                         type = CIFS_WRLCK;
1328                 lck = list_entry(el, struct lock_to_push, llist);
1329                 lck->pid = hash_lockowner(flock->fl_owner);
1330                 lck->netfid = cfile->fid.netfid;
1331                 lck->length = length;
1332                 lck->type = type;
1333                 lck->offset = flock->fl_start;
1334         }
1335         spin_unlock(&flctx->flc_lock);
1336
1337         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1338                 int stored_rc;
1339
1340                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1341                                              lck->offset, lck->length, NULL,
1342                                              lck->type, 0);
1343                 if (stored_rc)
1344                         rc = stored_rc;
1345                 list_del(&lck->llist);
1346                 kfree(lck);
1347         }
1348
1349 out:
1350         free_xid(xid);
1351         return rc;
1352 err_out:
1353         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1354                 list_del(&lck->llist);
1355                 kfree(lck);
1356         }
1357         goto out;
1358 }
1359
1360 static int
1361 cifs_push_locks(struct cifsFileInfo *cfile)
1362 {
1363         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1364         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1365         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1366         int rc = 0;
1367
1368         /* we are going to update can_cache_brlcks here - need a write access */
1369         cifs_down_write(&cinode->lock_sem);
1370         if (!cinode->can_cache_brlcks) {
1371                 up_write(&cinode->lock_sem);
1372                 return rc;
1373         }
1374
1375         if (cap_unix(tcon->ses) &&
1376             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1377             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1378                 rc = cifs_push_posix_locks(cfile);
1379         else
1380                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1381
1382         cinode->can_cache_brlcks = false;
1383         up_write(&cinode->lock_sem);
1384         return rc;
1385 }
1386
1387 static void
1388 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1389                 bool *wait_flag, struct TCP_Server_Info *server)
1390 {
1391         if (flock->fl_flags & FL_POSIX)
1392                 cifs_dbg(FYI, "Posix\n");
1393         if (flock->fl_flags & FL_FLOCK)
1394                 cifs_dbg(FYI, "Flock\n");
1395         if (flock->fl_flags & FL_SLEEP) {
1396                 cifs_dbg(FYI, "Blocking lock\n");
1397                 *wait_flag = true;
1398         }
1399         if (flock->fl_flags & FL_ACCESS)
1400                 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1401         if (flock->fl_flags & FL_LEASE)
1402                 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1403         if (flock->fl_flags &
1404             (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1405                FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1406                 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1407
1408         *type = server->vals->large_lock_type;
1409         if (flock->fl_type == F_WRLCK) {
1410                 cifs_dbg(FYI, "F_WRLCK\n");
1411                 *type |= server->vals->exclusive_lock_type;
1412                 *lock = 1;
1413         } else if (flock->fl_type == F_UNLCK) {
1414                 cifs_dbg(FYI, "F_UNLCK\n");
1415                 *type |= server->vals->unlock_lock_type;
1416                 *unlock = 1;
1417                 /* Check if unlock includes more than one lock range */
1418         } else if (flock->fl_type == F_RDLCK) {
1419                 cifs_dbg(FYI, "F_RDLCK\n");
1420                 *type |= server->vals->shared_lock_type;
1421                 *lock = 1;
1422         } else if (flock->fl_type == F_EXLCK) {
1423                 cifs_dbg(FYI, "F_EXLCK\n");
1424                 *type |= server->vals->exclusive_lock_type;
1425                 *lock = 1;
1426         } else if (flock->fl_type == F_SHLCK) {
1427                 cifs_dbg(FYI, "F_SHLCK\n");
1428                 *type |= server->vals->shared_lock_type;
1429                 *lock = 1;
1430         } else
1431                 cifs_dbg(FYI, "Unknown type of lock\n");
1432 }
1433
1434 static int
1435 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1436            bool wait_flag, bool posix_lck, unsigned int xid)
1437 {
1438         int rc = 0;
1439         __u64 length = 1 + flock->fl_end - flock->fl_start;
1440         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1441         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1442         struct TCP_Server_Info *server = tcon->ses->server;
1443         __u16 netfid = cfile->fid.netfid;
1444
1445         if (posix_lck) {
1446                 int posix_lock_type;
1447
1448                 rc = cifs_posix_lock_test(file, flock);
1449                 if (!rc)
1450                         return rc;
1451
1452                 if (type & server->vals->shared_lock_type)
1453                         posix_lock_type = CIFS_RDLCK;
1454                 else
1455                         posix_lock_type = CIFS_WRLCK;
1456                 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1457                                       hash_lockowner(flock->fl_owner),
1458                                       flock->fl_start, length, flock,
1459                                       posix_lock_type, wait_flag);
1460                 return rc;
1461         }
1462
1463         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1464         if (!rc)
1465                 return rc;
1466
1467         /* BB we could chain these into one lock request BB */
1468         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1469                                     1, 0, false);
1470         if (rc == 0) {
1471                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1472                                             type, 0, 1, false);
1473                 flock->fl_type = F_UNLCK;
1474                 if (rc != 0)
1475                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1476                                  rc);
1477                 return 0;
1478         }
1479
1480         if (type & server->vals->shared_lock_type) {
1481                 flock->fl_type = F_WRLCK;
1482                 return 0;
1483         }
1484
1485         type &= ~server->vals->exclusive_lock_type;
1486
1487         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1488                                     type | server->vals->shared_lock_type,
1489                                     1, 0, false);
1490         if (rc == 0) {
1491                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1492                         type | server->vals->shared_lock_type, 0, 1, false);
1493                 flock->fl_type = F_RDLCK;
1494                 if (rc != 0)
1495                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1496                                  rc);
1497         } else
1498                 flock->fl_type = F_WRLCK;
1499
1500         return 0;
1501 }
1502
1503 void
1504 cifs_move_llist(struct list_head *source, struct list_head *dest)
1505 {
1506         struct list_head *li, *tmp;
1507         list_for_each_safe(li, tmp, source)
1508                 list_move(li, dest);
1509 }
1510
1511 void
1512 cifs_free_llist(struct list_head *llist)
1513 {
1514         struct cifsLockInfo *li, *tmp;
1515         list_for_each_entry_safe(li, tmp, llist, llist) {
1516                 cifs_del_lock_waiters(li);
1517                 list_del(&li->llist);
1518                 kfree(li);
1519         }
1520 }
1521
1522 int
1523 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1524                   unsigned int xid)
1525 {
1526         int rc = 0, stored_rc;
1527         static const int types[] = {
1528                 LOCKING_ANDX_LARGE_FILES,
1529                 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1530         };
1531         unsigned int i;
1532         unsigned int max_num, num, max_buf;
1533         LOCKING_ANDX_RANGE *buf, *cur;
1534         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1535         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1536         struct cifsLockInfo *li, *tmp;
1537         __u64 length = 1 + flock->fl_end - flock->fl_start;
1538         struct list_head tmp_llist;
1539
1540         INIT_LIST_HEAD(&tmp_llist);
1541
1542         /*
1543          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1544          * and check it before using.
1545          */
1546         max_buf = tcon->ses->server->maxBuf;
1547         if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1548                 return -EINVAL;
1549
1550         BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1551                      PAGE_SIZE);
1552         max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1553                         PAGE_SIZE);
1554         max_num = (max_buf - sizeof(struct smb_hdr)) /
1555                                                 sizeof(LOCKING_ANDX_RANGE);
1556         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1557         if (!buf)
1558                 return -ENOMEM;
1559
1560         cifs_down_write(&cinode->lock_sem);
1561         for (i = 0; i < 2; i++) {
1562                 cur = buf;
1563                 num = 0;
1564                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1565                         if (flock->fl_start > li->offset ||
1566                             (flock->fl_start + length) <
1567                             (li->offset + li->length))
1568                                 continue;
1569                         if (current->tgid != li->pid)
1570                                 continue;
1571                         if (types[i] != li->type)
1572                                 continue;
1573                         if (cinode->can_cache_brlcks) {
1574                                 /*
1575                                  * We can cache brlock requests - simply remove
1576                                  * a lock from the file's list.
1577                                  */
1578                                 list_del(&li->llist);
1579                                 cifs_del_lock_waiters(li);
1580                                 kfree(li);
1581                                 continue;
1582                         }
1583                         cur->Pid = cpu_to_le16(li->pid);
1584                         cur->LengthLow = cpu_to_le32((u32)li->length);
1585                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1586                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1587                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1588                         /*
1589                          * We need to save a lock here to let us add it again to
1590                          * the file's list if the unlock range request fails on
1591                          * the server.
1592                          */
1593                         list_move(&li->llist, &tmp_llist);
1594                         if (++num == max_num) {
1595                                 stored_rc = cifs_lockv(xid, tcon,
1596                                                        cfile->fid.netfid,
1597                                                        li->type, num, 0, buf);
1598                                 if (stored_rc) {
1599                                         /*
1600                                          * We failed on the unlock range
1601                                          * request - add all locks from the tmp
1602                                          * list to the head of the file's list.
1603                                          */
1604                                         cifs_move_llist(&tmp_llist,
1605                                                         &cfile->llist->locks);
1606                                         rc = stored_rc;
1607                                 } else
1608                                         /*
1609                                          * The unlock range request succeed -
1610                                          * free the tmp list.
1611                                          */
1612                                         cifs_free_llist(&tmp_llist);
1613                                 cur = buf;
1614                                 num = 0;
1615                         } else
1616                                 cur++;
1617                 }
1618                 if (num) {
1619                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1620                                                types[i], num, 0, buf);
1621                         if (stored_rc) {
1622                                 cifs_move_llist(&tmp_llist,
1623                                                 &cfile->llist->locks);
1624                                 rc = stored_rc;
1625                         } else
1626                                 cifs_free_llist(&tmp_llist);
1627                 }
1628         }
1629
1630         up_write(&cinode->lock_sem);
1631         kfree(buf);
1632         return rc;
1633 }
1634
1635 static int
1636 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1637            bool wait_flag, bool posix_lck, int lock, int unlock,
1638            unsigned int xid)
1639 {
1640         int rc = 0;
1641         __u64 length = 1 + flock->fl_end - flock->fl_start;
1642         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1643         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1644         struct TCP_Server_Info *server = tcon->ses->server;
1645         struct inode *inode = d_inode(cfile->dentry);
1646
1647         if (posix_lck) {
1648                 int posix_lock_type;
1649
1650                 rc = cifs_posix_lock_set(file, flock);
1651                 if (!rc || rc < 0)
1652                         return rc;
1653
1654                 if (type & server->vals->shared_lock_type)
1655                         posix_lock_type = CIFS_RDLCK;
1656                 else
1657                         posix_lock_type = CIFS_WRLCK;
1658
1659                 if (unlock == 1)
1660                         posix_lock_type = CIFS_UNLCK;
1661
1662                 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1663                                       hash_lockowner(flock->fl_owner),
1664                                       flock->fl_start, length,
1665                                       NULL, posix_lock_type, wait_flag);
1666                 goto out;
1667         }
1668
1669         if (lock) {
1670                 struct cifsLockInfo *lock;
1671
1672                 lock = cifs_lock_init(flock->fl_start, length, type,
1673                                       flock->fl_flags);
1674                 if (!lock)
1675                         return -ENOMEM;
1676
1677                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1678                 if (rc < 0) {
1679                         kfree(lock);
1680                         return rc;
1681                 }
1682                 if (!rc)
1683                         goto out;
1684
1685                 /*
1686                  * Windows 7 server can delay breaking lease from read to None
1687                  * if we set a byte-range lock on a file - break it explicitly
1688                  * before sending the lock to the server to be sure the next
1689                  * read won't conflict with non-overlapted locks due to
1690                  * pagereading.
1691                  */
1692                 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1693                                         CIFS_CACHE_READ(CIFS_I(inode))) {
1694                         cifs_zap_mapping(inode);
1695                         cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1696                                  inode);
1697                         CIFS_I(inode)->oplock = 0;
1698                 }
1699
1700                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1701                                             type, 1, 0, wait_flag);
1702                 if (rc) {
1703                         kfree(lock);
1704                         return rc;
1705                 }
1706
1707                 cifs_lock_add(cfile, lock);
1708         } else if (unlock)
1709                 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1710
1711 out:
1712         if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) {
1713                 /*
1714                  * If this is a request to remove all locks because we
1715                  * are closing the file, it doesn't matter if the
1716                  * unlocking failed as both cifs.ko and the SMB server
1717                  * remove the lock on file close
1718                  */
1719                 if (rc) {
1720                         cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1721                         if (!(flock->fl_flags & FL_CLOSE))
1722                                 return rc;
1723                 }
1724                 rc = locks_lock_file_wait(file, flock);
1725         }
1726         return rc;
1727 }
1728
1729 int cifs_flock(struct file *file, int cmd, struct file_lock *fl)
1730 {
1731         int rc, xid;
1732         int lock = 0, unlock = 0;
1733         bool wait_flag = false;
1734         bool posix_lck = false;
1735         struct cifs_sb_info *cifs_sb;
1736         struct cifs_tcon *tcon;
1737         struct cifsFileInfo *cfile;
1738         __u32 type;
1739
1740         rc = -EACCES;
1741         xid = get_xid();
1742
1743         if (!(fl->fl_flags & FL_FLOCK))
1744                 return -ENOLCK;
1745
1746         cfile = (struct cifsFileInfo *)file->private_data;
1747         tcon = tlink_tcon(cfile->tlink);
1748
1749         cifs_read_flock(fl, &type, &lock, &unlock, &wait_flag,
1750                         tcon->ses->server);
1751         cifs_sb = CIFS_FILE_SB(file);
1752
1753         if (cap_unix(tcon->ses) &&
1754             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1755             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1756                 posix_lck = true;
1757
1758         if (!lock && !unlock) {
1759                 /*
1760                  * if no lock or unlock then nothing to do since we do not
1761                  * know what it is
1762                  */
1763                 free_xid(xid);
1764                 return -EOPNOTSUPP;
1765         }
1766
1767         rc = cifs_setlk(file, fl, type, wait_flag, posix_lck, lock, unlock,
1768                         xid);
1769         free_xid(xid);
1770         return rc;
1771
1772
1773 }
1774
1775 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1776 {
1777         int rc, xid;
1778         int lock = 0, unlock = 0;
1779         bool wait_flag = false;
1780         bool posix_lck = false;
1781         struct cifs_sb_info *cifs_sb;
1782         struct cifs_tcon *tcon;
1783         struct cifsFileInfo *cfile;
1784         __u32 type;
1785
1786         rc = -EACCES;
1787         xid = get_xid();
1788
1789         cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1790                  cmd, flock->fl_flags, flock->fl_type,
1791                  flock->fl_start, flock->fl_end);
1792
1793         cfile = (struct cifsFileInfo *)file->private_data;
1794         tcon = tlink_tcon(cfile->tlink);
1795
1796         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1797                         tcon->ses->server);
1798         cifs_sb = CIFS_FILE_SB(file);
1799
1800         if (cap_unix(tcon->ses) &&
1801             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1802             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1803                 posix_lck = true;
1804         /*
1805          * BB add code here to normalize offset and length to account for
1806          * negative length which we can not accept over the wire.
1807          */
1808         if (IS_GETLK(cmd)) {
1809                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1810                 free_xid(xid);
1811                 return rc;
1812         }
1813
1814         if (!lock && !unlock) {
1815                 /*
1816                  * if no lock or unlock then nothing to do since we do not
1817                  * know what it is
1818                  */
1819                 free_xid(xid);
1820                 return -EOPNOTSUPP;
1821         }
1822
1823         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1824                         xid);
1825         free_xid(xid);
1826         return rc;
1827 }
1828
1829 /*
1830  * update the file size (if needed) after a write. Should be called with
1831  * the inode->i_lock held
1832  */
1833 void
1834 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1835                       unsigned int bytes_written)
1836 {
1837         loff_t end_of_write = offset + bytes_written;
1838
1839         if (end_of_write > cifsi->server_eof)
1840                 cifsi->server_eof = end_of_write;
1841 }
1842
1843 static ssize_t
1844 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1845            size_t write_size, loff_t *offset)
1846 {
1847         int rc = 0;
1848         unsigned int bytes_written = 0;
1849         unsigned int total_written;
1850         struct cifs_tcon *tcon;
1851         struct TCP_Server_Info *server;
1852         unsigned int xid;
1853         struct dentry *dentry = open_file->dentry;
1854         struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1855         struct cifs_io_parms io_parms;
1856
1857         cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1858                  write_size, *offset, dentry);
1859
1860         tcon = tlink_tcon(open_file->tlink);
1861         server = tcon->ses->server;
1862
1863         if (!server->ops->sync_write)
1864                 return -ENOSYS;
1865
1866         xid = get_xid();
1867
1868         for (total_written = 0; write_size > total_written;
1869              total_written += bytes_written) {
1870                 rc = -EAGAIN;
1871                 while (rc == -EAGAIN) {
1872                         struct kvec iov[2];
1873                         unsigned int len;
1874
1875                         if (open_file->invalidHandle) {
1876                                 /* we could deadlock if we called
1877                                    filemap_fdatawait from here so tell
1878                                    reopen_file not to flush data to
1879                                    server now */
1880                                 rc = cifs_reopen_file(open_file, false);
1881                                 if (rc != 0)
1882                                         break;
1883                         }
1884
1885                         len = min(server->ops->wp_retry_size(d_inode(dentry)),
1886                                   (unsigned int)write_size - total_written);
1887                         /* iov[0] is reserved for smb header */
1888                         iov[1].iov_base = (char *)write_data + total_written;
1889                         iov[1].iov_len = len;
1890                         io_parms.pid = pid;
1891                         io_parms.tcon = tcon;
1892                         io_parms.offset = *offset;
1893                         io_parms.length = len;
1894                         rc = server->ops->sync_write(xid, &open_file->fid,
1895                                         &io_parms, &bytes_written, iov, 1);
1896                 }
1897                 if (rc || (bytes_written == 0)) {
1898                         if (total_written)
1899                                 break;
1900                         else {
1901                                 free_xid(xid);
1902                                 return rc;
1903                         }
1904                 } else {
1905                         spin_lock(&d_inode(dentry)->i_lock);
1906                         cifs_update_eof(cifsi, *offset, bytes_written);
1907                         spin_unlock(&d_inode(dentry)->i_lock);
1908                         *offset += bytes_written;
1909                 }
1910         }
1911
1912         cifs_stats_bytes_written(tcon, total_written);
1913
1914         if (total_written > 0) {
1915                 spin_lock(&d_inode(dentry)->i_lock);
1916                 if (*offset > d_inode(dentry)->i_size)
1917                         i_size_write(d_inode(dentry), *offset);
1918                 spin_unlock(&d_inode(dentry)->i_lock);
1919         }
1920         mark_inode_dirty_sync(d_inode(dentry));
1921         free_xid(xid);
1922         return total_written;
1923 }
1924
1925 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1926                                         bool fsuid_only)
1927 {
1928         struct cifsFileInfo *open_file = NULL;
1929         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1930
1931         /* only filter by fsuid on multiuser mounts */
1932         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1933                 fsuid_only = false;
1934
1935         spin_lock(&cifs_inode->open_file_lock);
1936         /* we could simply get the first_list_entry since write-only entries
1937            are always at the end of the list but since the first entry might
1938            have a close pending, we go through the whole list */
1939         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1940                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1941                         continue;
1942                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1943                         if (!open_file->invalidHandle) {
1944                                 /* found a good file */
1945                                 /* lock it so it will not be closed on us */
1946                                 cifsFileInfo_get(open_file);
1947                                 spin_unlock(&cifs_inode->open_file_lock);
1948                                 return open_file;
1949                         } /* else might as well continue, and look for
1950                              another, or simply have the caller reopen it
1951                              again rather than trying to fix this handle */
1952                 } else /* write only file */
1953                         break; /* write only files are last so must be done */
1954         }
1955         spin_unlock(&cifs_inode->open_file_lock);
1956         return NULL;
1957 }
1958
1959 /* Return -EBADF if no handle is found and general rc otherwise */
1960 int
1961 cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only,
1962                        struct cifsFileInfo **ret_file)
1963 {
1964         struct cifsFileInfo *open_file, *inv_file = NULL;
1965         struct cifs_sb_info *cifs_sb;
1966         bool any_available = false;
1967         int rc = -EBADF;
1968         unsigned int refind = 0;
1969
1970         *ret_file = NULL;
1971
1972         /*
1973          * Having a null inode here (because mapping->host was set to zero by
1974          * the VFS or MM) should not happen but we had reports of on oops (due
1975          * to it being zero) during stress testcases so we need to check for it
1976          */
1977
1978         if (cifs_inode == NULL) {
1979                 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1980                 dump_stack();
1981                 return rc;
1982         }
1983
1984         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1985
1986         /* only filter by fsuid on multiuser mounts */
1987         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1988                 fsuid_only = false;
1989
1990         spin_lock(&cifs_inode->open_file_lock);
1991 refind_writable:
1992         if (refind > MAX_REOPEN_ATT) {
1993                 spin_unlock(&cifs_inode->open_file_lock);
1994                 return rc;
1995         }
1996         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1997                 if (!any_available && open_file->pid != current->tgid)
1998                         continue;
1999                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2000                         continue;
2001                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2002                         if (!open_file->invalidHandle) {
2003                                 /* found a good writable file */
2004                                 cifsFileInfo_get(open_file);
2005                                 spin_unlock(&cifs_inode->open_file_lock);
2006                                 *ret_file = open_file;
2007                                 return 0;
2008                         } else {
2009                                 if (!inv_file)
2010                                         inv_file = open_file;
2011                         }
2012                 }
2013         }
2014         /* couldn't find useable FH with same pid, try any available */
2015         if (!any_available) {
2016                 any_available = true;
2017                 goto refind_writable;
2018         }
2019
2020         if (inv_file) {
2021                 any_available = false;
2022                 cifsFileInfo_get(inv_file);
2023         }
2024
2025         spin_unlock(&cifs_inode->open_file_lock);
2026
2027         if (inv_file) {
2028                 rc = cifs_reopen_file(inv_file, false);
2029                 if (!rc) {
2030                         *ret_file = inv_file;
2031                         return 0;
2032                 }
2033
2034                 spin_lock(&cifs_inode->open_file_lock);
2035                 list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
2036                 spin_unlock(&cifs_inode->open_file_lock);
2037                 cifsFileInfo_put(inv_file);
2038                 ++refind;
2039                 inv_file = NULL;
2040                 spin_lock(&cifs_inode->open_file_lock);
2041                 goto refind_writable;
2042         }
2043
2044         return rc;
2045 }
2046
2047 struct cifsFileInfo *
2048 find_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only)
2049 {
2050         struct cifsFileInfo *cfile;
2051         int rc;
2052
2053         rc = cifs_get_writable_file(cifs_inode, fsuid_only, &cfile);
2054         if (rc)
2055                 cifs_dbg(FYI, "couldn't find writable handle rc=%d", rc);
2056
2057         return cfile;
2058 }
2059
2060 int
2061 cifs_get_writable_path(struct cifs_tcon *tcon, const char *name,
2062                        struct cifsFileInfo **ret_file)
2063 {
2064         struct list_head *tmp;
2065         struct cifsFileInfo *cfile;
2066         struct cifsInodeInfo *cinode;
2067         char *full_path;
2068
2069         *ret_file = NULL;
2070
2071         spin_lock(&tcon->open_file_lock);
2072         list_for_each(tmp, &tcon->openFileList) {
2073                 cfile = list_entry(tmp, struct cifsFileInfo,
2074                              tlist);
2075                 full_path = build_path_from_dentry(cfile->dentry);
2076                 if (full_path == NULL) {
2077                         spin_unlock(&tcon->open_file_lock);
2078                         return -ENOMEM;
2079                 }
2080                 if (strcmp(full_path, name)) {
2081                         kfree(full_path);
2082                         continue;
2083                 }
2084
2085                 kfree(full_path);
2086                 cinode = CIFS_I(d_inode(cfile->dentry));
2087                 spin_unlock(&tcon->open_file_lock);
2088                 return cifs_get_writable_file(cinode, 0, ret_file);
2089         }
2090
2091         spin_unlock(&tcon->open_file_lock);
2092         return -ENOENT;
2093 }
2094
2095 int
2096 cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,
2097                        struct cifsFileInfo **ret_file)
2098 {
2099         struct list_head *tmp;
2100         struct cifsFileInfo *cfile;
2101         struct cifsInodeInfo *cinode;
2102         char *full_path;
2103
2104         *ret_file = NULL;
2105
2106         spin_lock(&tcon->open_file_lock);
2107         list_for_each(tmp, &tcon->openFileList) {
2108                 cfile = list_entry(tmp, struct cifsFileInfo,
2109                              tlist);
2110                 full_path = build_path_from_dentry(cfile->dentry);
2111                 if (full_path == NULL) {
2112                         spin_unlock(&tcon->open_file_lock);
2113                         return -ENOMEM;
2114                 }
2115                 if (strcmp(full_path, name)) {
2116                         kfree(full_path);
2117                         continue;
2118                 }
2119
2120                 kfree(full_path);
2121                 cinode = CIFS_I(d_inode(cfile->dentry));
2122                 spin_unlock(&tcon->open_file_lock);
2123                 *ret_file = find_readable_file(cinode, 0);
2124                 return *ret_file ? 0 : -ENOENT;
2125         }
2126
2127         spin_unlock(&tcon->open_file_lock);
2128         return -ENOENT;
2129 }
2130
2131 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
2132 {
2133         struct address_space *mapping = page->mapping;
2134         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
2135         char *write_data;
2136         int rc = -EFAULT;
2137         int bytes_written = 0;
2138         struct inode *inode;
2139         struct cifsFileInfo *open_file;
2140
2141         if (!mapping || !mapping->host)
2142                 return -EFAULT;
2143
2144         inode = page->mapping->host;
2145
2146         offset += (loff_t)from;
2147         write_data = kmap(page);
2148         write_data += from;
2149
2150         if ((to > PAGE_SIZE) || (from > to)) {
2151                 kunmap(page);
2152                 return -EIO;
2153         }
2154
2155         /* racing with truncate? */
2156         if (offset > mapping->host->i_size) {
2157                 kunmap(page);
2158                 return 0; /* don't care */
2159         }
2160
2161         /* check to make sure that we are not extending the file */
2162         if (mapping->host->i_size - offset < (loff_t)to)
2163                 to = (unsigned)(mapping->host->i_size - offset);
2164
2165         rc = cifs_get_writable_file(CIFS_I(mapping->host), false, &open_file);
2166         if (!rc) {
2167                 bytes_written = cifs_write(open_file, open_file->pid,
2168                                            write_data, to - from, &offset);
2169                 cifsFileInfo_put(open_file);
2170                 /* Does mm or vfs already set times? */
2171                 inode->i_atime = inode->i_mtime = current_time(inode);
2172                 if ((bytes_written > 0) && (offset))
2173                         rc = 0;
2174                 else if (bytes_written < 0)
2175                         rc = bytes_written;
2176                 else
2177                         rc = -EFAULT;
2178         } else {
2179                 cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2180                 if (!is_retryable_error(rc))
2181                         rc = -EIO;
2182         }
2183
2184         kunmap(page);
2185         return rc;
2186 }
2187
2188 static struct cifs_writedata *
2189 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2190                           pgoff_t end, pgoff_t *index,
2191                           unsigned int *found_pages)
2192 {
2193         struct cifs_writedata *wdata;
2194
2195         wdata = cifs_writedata_alloc((unsigned int)tofind,
2196                                      cifs_writev_complete);
2197         if (!wdata)
2198                 return NULL;
2199
2200         *found_pages = find_get_pages_range_tag(mapping, index, end,
2201                                 PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2202         return wdata;
2203 }
2204
2205 static unsigned int
2206 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2207                     struct address_space *mapping,
2208                     struct writeback_control *wbc,
2209                     pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2210 {
2211         unsigned int nr_pages = 0, i;
2212         struct page *page;
2213
2214         for (i = 0; i < found_pages; i++) {
2215                 page = wdata->pages[i];
2216                 /*
2217                  * At this point we hold neither the i_pages lock nor the
2218                  * page lock: the page may be truncated or invalidated
2219                  * (changing page->mapping to NULL), or even swizzled
2220                  * back from swapper_space to tmpfs file mapping
2221                  */
2222
2223                 if (nr_pages == 0)
2224                         lock_page(page);
2225                 else if (!trylock_page(page))
2226                         break;
2227
2228                 if (unlikely(page->mapping != mapping)) {
2229                         unlock_page(page);
2230                         break;
2231                 }
2232
2233                 if (!wbc->range_cyclic && page->index > end) {
2234                         *done = true;
2235                         unlock_page(page);
2236                         break;
2237                 }
2238
2239                 if (*next && (page->index != *next)) {
2240                         /* Not next consecutive page */
2241                         unlock_page(page);
2242                         break;
2243                 }
2244
2245                 if (wbc->sync_mode != WB_SYNC_NONE)
2246                         wait_on_page_writeback(page);
2247
2248                 if (PageWriteback(page) ||
2249                                 !clear_page_dirty_for_io(page)) {
2250                         unlock_page(page);
2251                         break;
2252                 }
2253
2254                 /*
2255                  * This actually clears the dirty bit in the radix tree.
2256                  * See cifs_writepage() for more commentary.
2257                  */
2258                 set_page_writeback(page);
2259                 if (page_offset(page) >= i_size_read(mapping->host)) {
2260                         *done = true;
2261                         unlock_page(page);
2262                         end_page_writeback(page);
2263                         break;
2264                 }
2265
2266                 wdata->pages[i] = page;
2267                 *next = page->index + 1;
2268                 ++nr_pages;
2269         }
2270
2271         /* reset index to refind any pages skipped */
2272         if (nr_pages == 0)
2273                 *index = wdata->pages[0]->index + 1;
2274
2275         /* put any pages we aren't going to use */
2276         for (i = nr_pages; i < found_pages; i++) {
2277                 put_page(wdata->pages[i]);
2278                 wdata->pages[i] = NULL;
2279         }
2280
2281         return nr_pages;
2282 }
2283
2284 static int
2285 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2286                  struct address_space *mapping, struct writeback_control *wbc)
2287 {
2288         int rc;
2289         struct TCP_Server_Info *server =
2290                                 tlink_tcon(wdata->cfile->tlink)->ses->server;
2291
2292         wdata->sync_mode = wbc->sync_mode;
2293         wdata->nr_pages = nr_pages;
2294         wdata->offset = page_offset(wdata->pages[0]);
2295         wdata->pagesz = PAGE_SIZE;
2296         wdata->tailsz = min(i_size_read(mapping->host) -
2297                         page_offset(wdata->pages[nr_pages - 1]),
2298                         (loff_t)PAGE_SIZE);
2299         wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2300         wdata->pid = wdata->cfile->pid;
2301
2302         rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2303         if (rc)
2304                 return rc;
2305
2306         if (wdata->cfile->invalidHandle)
2307                 rc = -EAGAIN;
2308         else
2309                 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2310
2311         return rc;
2312 }
2313
2314 static int cifs_writepages(struct address_space *mapping,
2315                            struct writeback_control *wbc)
2316 {
2317         struct inode *inode = mapping->host;
2318         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2319         struct TCP_Server_Info *server;
2320         bool done = false, scanned = false, range_whole = false;
2321         pgoff_t end, index;
2322         struct cifs_writedata *wdata;
2323         struct cifsFileInfo *cfile = NULL;
2324         int rc = 0;
2325         int saved_rc = 0;
2326         unsigned int xid;
2327
2328         /*
2329          * If wsize is smaller than the page cache size, default to writing
2330          * one page at a time via cifs_writepage
2331          */
2332         if (cifs_sb->wsize < PAGE_SIZE)
2333                 return generic_writepages(mapping, wbc);
2334
2335         xid = get_xid();
2336         if (wbc->range_cyclic) {
2337                 index = mapping->writeback_index; /* Start from prev offset */
2338                 end = -1;
2339         } else {
2340                 index = wbc->range_start >> PAGE_SHIFT;
2341                 end = wbc->range_end >> PAGE_SHIFT;
2342                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2343                         range_whole = true;
2344                 scanned = true;
2345         }
2346         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2347 retry:
2348         while (!done && index <= end) {
2349                 unsigned int i, nr_pages, found_pages, wsize;
2350                 pgoff_t next = 0, tofind, saved_index = index;
2351                 struct cifs_credits credits_on_stack;
2352                 struct cifs_credits *credits = &credits_on_stack;
2353                 int get_file_rc = 0;
2354
2355                 if (cfile)
2356                         cifsFileInfo_put(cfile);
2357
2358                 rc = cifs_get_writable_file(CIFS_I(inode), false, &cfile);
2359
2360                 /* in case of an error store it to return later */
2361                 if (rc)
2362                         get_file_rc = rc;
2363
2364                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2365                                                    &wsize, credits);
2366                 if (rc != 0) {
2367                         done = true;
2368                         break;
2369                 }
2370
2371                 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2372
2373                 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2374                                                   &found_pages);
2375                 if (!wdata) {
2376                         rc = -ENOMEM;
2377                         done = true;
2378                         add_credits_and_wake_if(server, credits, 0);
2379                         break;
2380                 }
2381
2382                 if (found_pages == 0) {
2383                         kref_put(&wdata->refcount, cifs_writedata_release);
2384                         add_credits_and_wake_if(server, credits, 0);
2385                         break;
2386                 }
2387
2388                 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2389                                                end, &index, &next, &done);
2390
2391                 /* nothing to write? */
2392                 if (nr_pages == 0) {
2393                         kref_put(&wdata->refcount, cifs_writedata_release);
2394                         add_credits_and_wake_if(server, credits, 0);
2395                         continue;
2396                 }
2397
2398                 wdata->credits = credits_on_stack;
2399                 wdata->cfile = cfile;
2400                 cfile = NULL;
2401
2402                 if (!wdata->cfile) {
2403                         cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2404                                  get_file_rc);
2405                         if (is_retryable_error(get_file_rc))
2406                                 rc = get_file_rc;
2407                         else
2408                                 rc = -EBADF;
2409                 } else
2410                         rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2411
2412                 for (i = 0; i < nr_pages; ++i)
2413                         unlock_page(wdata->pages[i]);
2414
2415                 /* send failure -- clean up the mess */
2416                 if (rc != 0) {
2417                         add_credits_and_wake_if(server, &wdata->credits, 0);
2418                         for (i = 0; i < nr_pages; ++i) {
2419                                 if (is_retryable_error(rc))
2420                                         redirty_page_for_writepage(wbc,
2421                                                            wdata->pages[i]);
2422                                 else
2423                                         SetPageError(wdata->pages[i]);
2424                                 end_page_writeback(wdata->pages[i]);
2425                                 put_page(wdata->pages[i]);
2426                         }
2427                         if (!is_retryable_error(rc))
2428                                 mapping_set_error(mapping, rc);
2429                 }
2430                 kref_put(&wdata->refcount, cifs_writedata_release);
2431
2432                 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2433                         index = saved_index;
2434                         continue;
2435                 }
2436
2437                 /* Return immediately if we received a signal during writing */
2438                 if (is_interrupt_error(rc)) {
2439                         done = true;
2440                         break;
2441                 }
2442
2443                 if (rc != 0 && saved_rc == 0)
2444                         saved_rc = rc;
2445
2446                 wbc->nr_to_write -= nr_pages;
2447                 if (wbc->nr_to_write <= 0)
2448                         done = true;
2449
2450                 index = next;
2451         }
2452
2453         if (!scanned && !done) {
2454                 /*
2455                  * We hit the last page and there is more work to be done: wrap
2456                  * back to the start of the file
2457                  */
2458                 scanned = true;
2459                 index = 0;
2460                 goto retry;
2461         }
2462
2463         if (saved_rc != 0)
2464                 rc = saved_rc;
2465
2466         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2467                 mapping->writeback_index = index;
2468
2469         if (cfile)
2470                 cifsFileInfo_put(cfile);
2471         free_xid(xid);
2472         return rc;
2473 }
2474
2475 static int
2476 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2477 {
2478         int rc;
2479         unsigned int xid;
2480
2481         xid = get_xid();
2482 /* BB add check for wbc flags */
2483         get_page(page);
2484         if (!PageUptodate(page))
2485                 cifs_dbg(FYI, "ppw - page not up to date\n");
2486
2487         /*
2488          * Set the "writeback" flag, and clear "dirty" in the radix tree.
2489          *
2490          * A writepage() implementation always needs to do either this,
2491          * or re-dirty the page with "redirty_page_for_writepage()" in
2492          * the case of a failure.
2493          *
2494          * Just unlocking the page will cause the radix tree tag-bits
2495          * to fail to update with the state of the page correctly.
2496          */
2497         set_page_writeback(page);
2498 retry_write:
2499         rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2500         if (is_retryable_error(rc)) {
2501                 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2502                         goto retry_write;
2503                 redirty_page_for_writepage(wbc, page);
2504         } else if (rc != 0) {
2505                 SetPageError(page);
2506                 mapping_set_error(page->mapping, rc);
2507         } else {
2508                 SetPageUptodate(page);
2509         }
2510         end_page_writeback(page);
2511         put_page(page);
2512         free_xid(xid);
2513         return rc;
2514 }
2515
2516 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2517 {
2518         int rc = cifs_writepage_locked(page, wbc);
2519         unlock_page(page);
2520         return rc;
2521 }
2522
2523 static int cifs_write_end(struct file *file, struct address_space *mapping,
2524                         loff_t pos, unsigned len, unsigned copied,
2525                         struct page *page, void *fsdata)
2526 {
2527         int rc;
2528         struct inode *inode = mapping->host;
2529         struct cifsFileInfo *cfile = file->private_data;
2530         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2531         __u32 pid;
2532
2533         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2534                 pid = cfile->pid;
2535         else
2536                 pid = current->tgid;
2537
2538         cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2539                  page, pos, copied);
2540
2541         if (PageChecked(page)) {
2542                 if (copied == len)
2543                         SetPageUptodate(page);
2544                 ClearPageChecked(page);
2545         } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2546                 SetPageUptodate(page);
2547
2548         if (!PageUptodate(page)) {
2549                 char *page_data;
2550                 unsigned offset = pos & (PAGE_SIZE - 1);
2551                 unsigned int xid;
2552
2553                 xid = get_xid();
2554                 /* this is probably better than directly calling
2555                    partialpage_write since in this function the file handle is
2556                    known which we might as well leverage */
2557                 /* BB check if anything else missing out of ppw
2558                    such as updating last write time */
2559                 page_data = kmap(page);
2560                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2561                 /* if (rc < 0) should we set writebehind rc? */
2562                 kunmap(page);
2563
2564                 free_xid(xid);
2565         } else {
2566                 rc = copied;
2567                 pos += copied;
2568                 set_page_dirty(page);
2569         }
2570
2571         if (rc > 0) {
2572                 spin_lock(&inode->i_lock);
2573                 if (pos > inode->i_size)
2574                         i_size_write(inode, pos);
2575                 spin_unlock(&inode->i_lock);
2576         }
2577
2578         unlock_page(page);
2579         put_page(page);
2580
2581         return rc;
2582 }
2583
2584 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2585                       int datasync)
2586 {
2587         unsigned int xid;
2588         int rc = 0;
2589         struct cifs_tcon *tcon;
2590         struct TCP_Server_Info *server;
2591         struct cifsFileInfo *smbfile = file->private_data;
2592         struct inode *inode = file_inode(file);
2593         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2594
2595         rc = file_write_and_wait_range(file, start, end);
2596         if (rc)
2597                 return rc;
2598
2599         xid = get_xid();
2600
2601         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2602                  file, datasync);
2603
2604         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2605                 rc = cifs_zap_mapping(inode);
2606                 if (rc) {
2607                         cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2608                         rc = 0; /* don't care about it in fsync */
2609                 }
2610         }
2611
2612         tcon = tlink_tcon(smbfile->tlink);
2613         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2614                 server = tcon->ses->server;
2615                 if (server->ops->flush)
2616                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2617                 else
2618                         rc = -ENOSYS;
2619         }
2620
2621         free_xid(xid);
2622         return rc;
2623 }
2624
2625 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2626 {
2627         unsigned int xid;
2628         int rc = 0;
2629         struct cifs_tcon *tcon;
2630         struct TCP_Server_Info *server;
2631         struct cifsFileInfo *smbfile = file->private_data;
2632         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2633
2634         rc = file_write_and_wait_range(file, start, end);
2635         if (rc)
2636                 return rc;
2637
2638         xid = get_xid();
2639
2640         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2641                  file, datasync);
2642
2643         tcon = tlink_tcon(smbfile->tlink);
2644         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2645                 server = tcon->ses->server;
2646                 if (server->ops->flush)
2647                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2648                 else
2649                         rc = -ENOSYS;
2650         }
2651
2652         free_xid(xid);
2653         return rc;
2654 }
2655
2656 /*
2657  * As file closes, flush all cached write data for this inode checking
2658  * for write behind errors.
2659  */
2660 int cifs_flush(struct file *file, fl_owner_t id)
2661 {
2662         struct inode *inode = file_inode(file);
2663         int rc = 0;
2664
2665         if (file->f_mode & FMODE_WRITE)
2666                 rc = filemap_write_and_wait(inode->i_mapping);
2667
2668         cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2669
2670         return rc;
2671 }
2672
2673 static int
2674 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2675 {
2676         int rc = 0;
2677         unsigned long i;
2678
2679         for (i = 0; i < num_pages; i++) {
2680                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2681                 if (!pages[i]) {
2682                         /*
2683                          * save number of pages we have already allocated and
2684                          * return with ENOMEM error
2685                          */
2686                         num_pages = i;
2687                         rc = -ENOMEM;
2688                         break;
2689                 }
2690         }
2691
2692         if (rc) {
2693                 for (i = 0; i < num_pages; i++)
2694                         put_page(pages[i]);
2695         }
2696         return rc;
2697 }
2698
2699 static inline
2700 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2701 {
2702         size_t num_pages;
2703         size_t clen;
2704
2705         clen = min_t(const size_t, len, wsize);
2706         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2707
2708         if (cur_len)
2709                 *cur_len = clen;
2710
2711         return num_pages;
2712 }
2713
2714 static void
2715 cifs_uncached_writedata_release(struct kref *refcount)
2716 {
2717         int i;
2718         struct cifs_writedata *wdata = container_of(refcount,
2719                                         struct cifs_writedata, refcount);
2720
2721         kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2722         for (i = 0; i < wdata->nr_pages; i++)
2723                 put_page(wdata->pages[i]);
2724         cifs_writedata_release(refcount);
2725 }
2726
2727 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2728
2729 static void
2730 cifs_uncached_writev_complete(struct work_struct *work)
2731 {
2732         struct cifs_writedata *wdata = container_of(work,
2733                                         struct cifs_writedata, work);
2734         struct inode *inode = d_inode(wdata->cfile->dentry);
2735         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2736
2737         spin_lock(&inode->i_lock);
2738         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2739         if (cifsi->server_eof > inode->i_size)
2740                 i_size_write(inode, cifsi->server_eof);
2741         spin_unlock(&inode->i_lock);
2742
2743         complete(&wdata->done);
2744         collect_uncached_write_data(wdata->ctx);
2745         /* the below call can possibly free the last ref to aio ctx */
2746         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2747 }
2748
2749 static int
2750 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2751                       size_t *len, unsigned long *num_pages)
2752 {
2753         size_t save_len, copied, bytes, cur_len = *len;
2754         unsigned long i, nr_pages = *num_pages;
2755
2756         save_len = cur_len;
2757         for (i = 0; i < nr_pages; i++) {
2758                 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2759                 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2760                 cur_len -= copied;
2761                 /*
2762                  * If we didn't copy as much as we expected, then that
2763                  * may mean we trod into an unmapped area. Stop copying
2764                  * at that point. On the next pass through the big
2765                  * loop, we'll likely end up getting a zero-length
2766                  * write and bailing out of it.
2767                  */
2768                 if (copied < bytes)
2769                         break;
2770         }
2771         cur_len = save_len - cur_len;
2772         *len = cur_len;
2773
2774         /*
2775          * If we have no data to send, then that probably means that
2776          * the copy above failed altogether. That's most likely because
2777          * the address in the iovec was bogus. Return -EFAULT and let
2778          * the caller free anything we allocated and bail out.
2779          */
2780         if (!cur_len)
2781                 return -EFAULT;
2782
2783         /*
2784          * i + 1 now represents the number of pages we actually used in
2785          * the copy phase above.
2786          */
2787         *num_pages = i + 1;
2788         return 0;
2789 }
2790
2791 static int
2792 cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
2793         struct cifs_aio_ctx *ctx)
2794 {
2795         unsigned int wsize;
2796         struct cifs_credits credits;
2797         int rc;
2798         struct TCP_Server_Info *server =
2799                 tlink_tcon(wdata->cfile->tlink)->ses->server;
2800
2801         do {
2802                 if (wdata->cfile->invalidHandle) {
2803                         rc = cifs_reopen_file(wdata->cfile, false);
2804                         if (rc == -EAGAIN)
2805                                 continue;
2806                         else if (rc)
2807                                 break;
2808                 }
2809
2810
2811                 /*
2812                  * Wait for credits to resend this wdata.
2813                  * Note: we are attempting to resend the whole wdata not in
2814                  * segments
2815                  */
2816                 do {
2817                         rc = server->ops->wait_mtu_credits(server, wdata->bytes,
2818                                                 &wsize, &credits);
2819                         if (rc)
2820                                 goto fail;
2821
2822                         if (wsize < wdata->bytes) {
2823                                 add_credits_and_wake_if(server, &credits, 0);
2824                                 msleep(1000);
2825                         }
2826                 } while (wsize < wdata->bytes);
2827                 wdata->credits = credits;
2828
2829                 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2830
2831                 if (!rc) {
2832                         if (wdata->cfile->invalidHandle)
2833                                 rc = -EAGAIN;
2834                         else {
2835 #ifdef CONFIG_CIFS_SMB_DIRECT
2836                                 if (wdata->mr) {
2837                                         wdata->mr->need_invalidate = true;
2838                                         smbd_deregister_mr(wdata->mr);
2839                                         wdata->mr = NULL;
2840                                 }
2841 #endif
2842                                 rc = server->ops->async_writev(wdata,
2843                                         cifs_uncached_writedata_release);
2844                         }
2845                 }
2846
2847                 /* If the write was successfully sent, we are done */
2848                 if (!rc) {
2849                         list_add_tail(&wdata->list, wdata_list);
2850                         return 0;
2851                 }
2852
2853                 /* Roll back credits and retry if needed */
2854                 add_credits_and_wake_if(server, &wdata->credits, 0);
2855         } while (rc == -EAGAIN);
2856
2857 fail:
2858         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2859         return rc;
2860 }
2861
2862 static int
2863 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2864                      struct cifsFileInfo *open_file,
2865                      struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2866                      struct cifs_aio_ctx *ctx)
2867 {
2868         int rc = 0;
2869         size_t cur_len;
2870         unsigned long nr_pages, num_pages, i;
2871         struct cifs_writedata *wdata;
2872         struct iov_iter saved_from = *from;
2873         loff_t saved_offset = offset;
2874         pid_t pid;
2875         struct TCP_Server_Info *server;
2876         struct page **pagevec;
2877         size_t start;
2878         unsigned int xid;
2879
2880         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2881                 pid = open_file->pid;
2882         else
2883                 pid = current->tgid;
2884
2885         server = tlink_tcon(open_file->tlink)->ses->server;
2886         xid = get_xid();
2887
2888         do {
2889                 unsigned int wsize;
2890                 struct cifs_credits credits_on_stack;
2891                 struct cifs_credits *credits = &credits_on_stack;
2892
2893                 if (open_file->invalidHandle) {
2894                         rc = cifs_reopen_file(open_file, false);
2895                         if (rc == -EAGAIN)
2896                                 continue;
2897                         else if (rc)
2898                                 break;
2899                 }
2900
2901                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2902                                                    &wsize, credits);
2903                 if (rc)
2904                         break;
2905
2906                 cur_len = min_t(const size_t, len, wsize);
2907
2908                 if (ctx->direct_io) {
2909                         ssize_t result;
2910
2911                         result = iov_iter_get_pages_alloc(
2912                                 from, &pagevec, cur_len, &start);
2913                         if (result < 0) {
2914                                 cifs_dbg(VFS,
2915                                         "direct_writev couldn't get user pages "
2916                                         "(rc=%zd) iter type %d iov_offset %zd "
2917                                         "count %zd\n",
2918                                         result, iov_iter_type(from),
2919                                         from->iov_offset, from->count);
2920                                 dump_stack();
2921
2922                                 rc = result;
2923                                 add_credits_and_wake_if(server, credits, 0);
2924                                 break;
2925                         }
2926                         cur_len = (size_t)result;
2927                         iov_iter_advance(from, cur_len);
2928
2929                         nr_pages =
2930                                 (cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
2931
2932                         wdata = cifs_writedata_direct_alloc(pagevec,
2933                                              cifs_uncached_writev_complete);
2934                         if (!wdata) {
2935                                 rc = -ENOMEM;
2936                                 add_credits_and_wake_if(server, credits, 0);
2937                                 break;
2938                         }
2939
2940
2941                         wdata->page_offset = start;
2942                         wdata->tailsz =
2943                                 nr_pages > 1 ?
2944                                         cur_len - (PAGE_SIZE - start) -
2945                                         (nr_pages - 2) * PAGE_SIZE :
2946                                         cur_len;
2947                 } else {
2948                         nr_pages = get_numpages(wsize, len, &cur_len);
2949                         wdata = cifs_writedata_alloc(nr_pages,
2950                                              cifs_uncached_writev_complete);
2951                         if (!wdata) {
2952                                 rc = -ENOMEM;
2953                                 add_credits_and_wake_if(server, credits, 0);
2954                                 break;
2955                         }
2956
2957                         rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2958                         if (rc) {
2959                                 kvfree(wdata->pages);
2960                                 kfree(wdata);
2961                                 add_credits_and_wake_if(server, credits, 0);
2962                                 break;
2963                         }
2964
2965                         num_pages = nr_pages;
2966                         rc = wdata_fill_from_iovec(
2967                                 wdata, from, &cur_len, &num_pages);
2968                         if (rc) {
2969                                 for (i = 0; i < nr_pages; i++)
2970                                         put_page(wdata->pages[i]);
2971                                 kvfree(wdata->pages);
2972                                 kfree(wdata);
2973                                 add_credits_and_wake_if(server, credits, 0);
2974                                 break;
2975                         }
2976
2977                         /*
2978                          * Bring nr_pages down to the number of pages we
2979                          * actually used, and free any pages that we didn't use.
2980                          */
2981                         for ( ; nr_pages > num_pages; nr_pages--)
2982                                 put_page(wdata->pages[nr_pages - 1]);
2983
2984                         wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2985                 }
2986
2987                 wdata->sync_mode = WB_SYNC_ALL;
2988                 wdata->nr_pages = nr_pages;
2989                 wdata->offset = (__u64)offset;
2990                 wdata->cfile = cifsFileInfo_get(open_file);
2991                 wdata->pid = pid;
2992                 wdata->bytes = cur_len;
2993                 wdata->pagesz = PAGE_SIZE;
2994                 wdata->credits = credits_on_stack;
2995                 wdata->ctx = ctx;
2996                 kref_get(&ctx->refcount);
2997
2998                 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2999
3000                 if (!rc) {
3001                         if (wdata->cfile->invalidHandle)
3002                                 rc = -EAGAIN;
3003                         else
3004                                 rc = server->ops->async_writev(wdata,
3005                                         cifs_uncached_writedata_release);
3006                 }
3007
3008                 if (rc) {
3009                         add_credits_and_wake_if(server, &wdata->credits, 0);
3010                         kref_put(&wdata->refcount,
3011                                  cifs_uncached_writedata_release);
3012                         if (rc == -EAGAIN) {
3013                                 *from = saved_from;
3014                                 iov_iter_advance(from, offset - saved_offset);
3015                                 continue;
3016                         }
3017                         break;
3018                 }
3019
3020                 list_add_tail(&wdata->list, wdata_list);
3021                 offset += cur_len;
3022                 len -= cur_len;
3023         } while (len > 0);
3024
3025         free_xid(xid);
3026         return rc;
3027 }
3028
3029 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
3030 {
3031         struct cifs_writedata *wdata, *tmp;
3032         struct cifs_tcon *tcon;
3033         struct cifs_sb_info *cifs_sb;
3034         struct dentry *dentry = ctx->cfile->dentry;
3035         int rc;
3036
3037         tcon = tlink_tcon(ctx->cfile->tlink);
3038         cifs_sb = CIFS_SB(dentry->d_sb);
3039
3040         mutex_lock(&ctx->aio_mutex);
3041
3042         if (list_empty(&ctx->list)) {
3043                 mutex_unlock(&ctx->aio_mutex);
3044                 return;
3045         }
3046
3047         rc = ctx->rc;
3048         /*
3049          * Wait for and collect replies for any successful sends in order of
3050          * increasing offset. Once an error is hit, then return without waiting
3051          * for any more replies.
3052          */
3053 restart_loop:
3054         list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
3055                 if (!rc) {
3056                         if (!try_wait_for_completion(&wdata->done)) {
3057                                 mutex_unlock(&ctx->aio_mutex);
3058                                 return;
3059                         }
3060
3061                         if (wdata->result)
3062                                 rc = wdata->result;
3063                         else
3064                                 ctx->total_len += wdata->bytes;
3065
3066                         /* resend call if it's a retryable error */
3067                         if (rc == -EAGAIN) {
3068                                 struct list_head tmp_list;
3069                                 struct iov_iter tmp_from = ctx->iter;
3070
3071                                 INIT_LIST_HEAD(&tmp_list);
3072                                 list_del_init(&wdata->list);
3073
3074                                 if (ctx->direct_io)
3075                                         rc = cifs_resend_wdata(
3076                                                 wdata, &tmp_list, ctx);
3077                                 else {
3078                                         iov_iter_advance(&tmp_from,
3079                                                  wdata->offset - ctx->pos);
3080
3081                                         rc = cifs_write_from_iter(wdata->offset,
3082                                                 wdata->bytes, &tmp_from,
3083                                                 ctx->cfile, cifs_sb, &tmp_list,
3084                                                 ctx);
3085
3086                                         kref_put(&wdata->refcount,
3087                                                 cifs_uncached_writedata_release);
3088                                 }
3089
3090                                 list_splice(&tmp_list, &ctx->list);
3091                                 goto restart_loop;
3092                         }
3093                 }
3094                 list_del_init(&wdata->list);
3095                 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3096         }
3097
3098         cifs_stats_bytes_written(tcon, ctx->total_len);
3099         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
3100
3101         ctx->rc = (rc == 0) ? ctx->total_len : rc;
3102
3103         mutex_unlock(&ctx->aio_mutex);
3104
3105         if (ctx->iocb && ctx->iocb->ki_complete)
3106                 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3107         else
3108                 complete(&ctx->done);
3109 }
3110
3111 static ssize_t __cifs_writev(
3112         struct kiocb *iocb, struct iov_iter *from, bool direct)
3113 {
3114         struct file *file = iocb->ki_filp;
3115         ssize_t total_written = 0;
3116         struct cifsFileInfo *cfile;
3117         struct cifs_tcon *tcon;
3118         struct cifs_sb_info *cifs_sb;
3119         struct cifs_aio_ctx *ctx;
3120         struct iov_iter saved_from = *from;
3121         size_t len = iov_iter_count(from);
3122         int rc;
3123
3124         /*
3125          * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
3126          * In this case, fall back to non-direct write function.
3127          * this could be improved by getting pages directly in ITER_KVEC
3128          */
3129         if (direct && iov_iter_is_kvec(from)) {
3130                 cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
3131                 direct = false;
3132         }
3133
3134         rc = generic_write_checks(iocb, from);
3135         if (rc <= 0)
3136                 return rc;
3137
3138         cifs_sb = CIFS_FILE_SB(file);
3139         cfile = file->private_data;
3140         tcon = tlink_tcon(cfile->tlink);
3141
3142         if (!tcon->ses->server->ops->async_writev)
3143                 return -ENOSYS;
3144
3145         ctx = cifs_aio_ctx_alloc();
3146         if (!ctx)
3147                 return -ENOMEM;
3148
3149         ctx->cfile = cifsFileInfo_get(cfile);
3150
3151         if (!is_sync_kiocb(iocb))
3152                 ctx->iocb = iocb;
3153
3154         ctx->pos = iocb->ki_pos;
3155
3156         if (direct) {
3157                 ctx->direct_io = true;
3158                 ctx->iter = *from;
3159                 ctx->len = len;
3160         } else {
3161                 rc = setup_aio_ctx_iter(ctx, from, WRITE);
3162                 if (rc) {
3163                         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3164                         return rc;
3165                 }
3166         }
3167
3168         /* grab a lock here due to read response handlers can access ctx */
3169         mutex_lock(&ctx->aio_mutex);
3170
3171         rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3172                                   cfile, cifs_sb, &ctx->list, ctx);
3173
3174         /*
3175          * If at least one write was successfully sent, then discard any rc
3176          * value from the later writes. If the other write succeeds, then
3177          * we'll end up returning whatever was written. If it fails, then
3178          * we'll get a new rc value from that.
3179          */
3180         if (!list_empty(&ctx->list))
3181                 rc = 0;
3182
3183         mutex_unlock(&ctx->aio_mutex);
3184
3185         if (rc) {
3186                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3187                 return rc;
3188         }
3189
3190         if (!is_sync_kiocb(iocb)) {
3191                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3192                 return -EIOCBQUEUED;
3193         }
3194
3195         rc = wait_for_completion_killable(&ctx->done);
3196         if (rc) {
3197                 mutex_lock(&ctx->aio_mutex);
3198                 ctx->rc = rc = -EINTR;
3199                 total_written = ctx->total_len;
3200                 mutex_unlock(&ctx->aio_mutex);
3201         } else {
3202                 rc = ctx->rc;
3203                 total_written = ctx->total_len;
3204         }
3205
3206         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3207
3208         if (unlikely(!total_written))
3209                 return rc;
3210
3211         iocb->ki_pos += total_written;
3212         return total_written;
3213 }
3214
3215 ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3216 {
3217         return __cifs_writev(iocb, from, true);
3218 }
3219
3220 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3221 {
3222         return __cifs_writev(iocb, from, false);
3223 }
3224
3225 static ssize_t
3226 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3227 {
3228         struct file *file = iocb->ki_filp;
3229         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3230         struct inode *inode = file->f_mapping->host;
3231         struct cifsInodeInfo *cinode = CIFS_I(inode);
3232         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3233         ssize_t rc;
3234
3235         inode_lock(inode);
3236         /*
3237          * We need to hold the sem to be sure nobody modifies lock list
3238          * with a brlock that prevents writing.
3239          */
3240         down_read(&cinode->lock_sem);
3241
3242         rc = generic_write_checks(iocb, from);
3243         if (rc <= 0)
3244                 goto out;
3245
3246         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3247                                      server->vals->exclusive_lock_type, 0,
3248                                      NULL, CIFS_WRITE_OP))
3249                 rc = __generic_file_write_iter(iocb, from);
3250         else
3251                 rc = -EACCES;
3252 out:
3253         up_read(&cinode->lock_sem);
3254         inode_unlock(inode);
3255
3256         if (rc > 0)
3257                 rc = generic_write_sync(iocb, rc);
3258         return rc;
3259 }
3260
3261 ssize_t
3262 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3263 {
3264         struct inode *inode = file_inode(iocb->ki_filp);
3265         struct cifsInodeInfo *cinode = CIFS_I(inode);
3266         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3267         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3268                                                 iocb->ki_filp->private_data;
3269         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3270         ssize_t written;
3271
3272         written = cifs_get_writer(cinode);
3273         if (written)
3274                 return written;
3275
3276         if (CIFS_CACHE_WRITE(cinode)) {
3277                 if (cap_unix(tcon->ses) &&
3278                 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3279                   && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3280                         written = generic_file_write_iter(iocb, from);
3281                         goto out;
3282                 }
3283                 written = cifs_writev(iocb, from);
3284                 goto out;
3285         }
3286         /*
3287          * For non-oplocked files in strict cache mode we need to write the data
3288          * to the server exactly from the pos to pos+len-1 rather than flush all
3289          * affected pages because it may cause a error with mandatory locks on
3290          * these pages but not on the region from pos to ppos+len-1.
3291          */
3292         written = cifs_user_writev(iocb, from);
3293         if (CIFS_CACHE_READ(cinode)) {
3294                 /*
3295                  * We have read level caching and we have just sent a write
3296                  * request to the server thus making data in the cache stale.
3297                  * Zap the cache and set oplock/lease level to NONE to avoid
3298                  * reading stale data from the cache. All subsequent read
3299                  * operations will read new data from the server.
3300                  */
3301                 cifs_zap_mapping(inode);
3302                 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3303                          inode);
3304                 cinode->oplock = 0;
3305         }
3306 out:
3307         cifs_put_writer(cinode);
3308         return written;
3309 }
3310
3311 static struct cifs_readdata *
3312 cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3313 {
3314         struct cifs_readdata *rdata;
3315
3316         rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3317         if (rdata != NULL) {
3318                 rdata->pages = pages;
3319                 kref_init(&rdata->refcount);
3320                 INIT_LIST_HEAD(&rdata->list);
3321                 init_completion(&rdata->done);
3322                 INIT_WORK(&rdata->work, complete);
3323         }
3324
3325         return rdata;
3326 }
3327
3328 static struct cifs_readdata *
3329 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3330 {
3331         struct page **pages =
3332                 kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3333         struct cifs_readdata *ret = NULL;
3334
3335         if (pages) {
3336                 ret = cifs_readdata_direct_alloc(pages, complete);
3337                 if (!ret)
3338                         kfree(pages);
3339         }
3340
3341         return ret;
3342 }
3343
3344 void
3345 cifs_readdata_release(struct kref *refcount)
3346 {
3347         struct cifs_readdata *rdata = container_of(refcount,
3348                                         struct cifs_readdata, refcount);
3349 #ifdef CONFIG_CIFS_SMB_DIRECT
3350         if (rdata->mr) {
3351                 smbd_deregister_mr(rdata->mr);
3352                 rdata->mr = NULL;
3353         }
3354 #endif
3355         if (rdata->cfile)
3356                 cifsFileInfo_put(rdata->cfile);
3357
3358         kvfree(rdata->pages);
3359         kfree(rdata);
3360 }
3361
3362 static int
3363 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3364 {
3365         int rc = 0;
3366         struct page *page;
3367         unsigned int i;
3368
3369         for (i = 0; i < nr_pages; i++) {
3370                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3371                 if (!page) {
3372                         rc = -ENOMEM;
3373                         break;
3374                 }
3375                 rdata->pages[i] = page;
3376         }
3377
3378         if (rc) {
3379                 unsigned int nr_page_failed = i;
3380
3381                 for (i = 0; i < nr_page_failed; i++) {
3382                         put_page(rdata->pages[i]);
3383                         rdata->pages[i] = NULL;
3384                 }
3385         }
3386         return rc;
3387 }
3388
3389 static void
3390 cifs_uncached_readdata_release(struct kref *refcount)
3391 {
3392         struct cifs_readdata *rdata = container_of(refcount,
3393                                         struct cifs_readdata, refcount);
3394         unsigned int i;
3395
3396         kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3397         for (i = 0; i < rdata->nr_pages; i++) {
3398                 put_page(rdata->pages[i]);
3399         }
3400         cifs_readdata_release(refcount);
3401 }
3402
3403 /**
3404  * cifs_readdata_to_iov - copy data from pages in response to an iovec
3405  * @rdata:      the readdata response with list of pages holding data
3406  * @iter:       destination for our data
3407  *
3408  * This function copies data from a list of pages in a readdata response into
3409  * an array of iovecs. It will first calculate where the data should go
3410  * based on the info in the readdata and then copy the data into that spot.
3411  */
3412 static int
3413 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3414 {
3415         size_t remaining = rdata->got_bytes;
3416         unsigned int i;
3417
3418         for (i = 0; i < rdata->nr_pages; i++) {
3419                 struct page *page = rdata->pages[i];
3420                 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3421                 size_t written;
3422
3423                 if (unlikely(iov_iter_is_pipe(iter))) {
3424                         void *addr = kmap_atomic(page);
3425
3426                         written = copy_to_iter(addr, copy, iter);
3427                         kunmap_atomic(addr);
3428                 } else
3429                         written = copy_page_to_iter(page, 0, copy, iter);
3430                 remaining -= written;
3431                 if (written < copy && iov_iter_count(iter) > 0)
3432                         break;
3433         }
3434         return remaining ? -EFAULT : 0;
3435 }
3436
3437 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3438
3439 static void
3440 cifs_uncached_readv_complete(struct work_struct *work)
3441 {
3442         struct cifs_readdata *rdata = container_of(work,
3443                                                 struct cifs_readdata, work);
3444
3445         complete(&rdata->done);
3446         collect_uncached_read_data(rdata->ctx);
3447         /* the below call can possibly free the last ref to aio ctx */
3448         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3449 }
3450
3451 static int
3452 uncached_fill_pages(struct TCP_Server_Info *server,
3453                     struct cifs_readdata *rdata, struct iov_iter *iter,
3454                     unsigned int len)
3455 {
3456         int result = 0;
3457         unsigned int i;
3458         unsigned int nr_pages = rdata->nr_pages;
3459         unsigned int page_offset = rdata->page_offset;
3460
3461         rdata->got_bytes = 0;
3462         rdata->tailsz = PAGE_SIZE;
3463         for (i = 0; i < nr_pages; i++) {
3464                 struct page *page = rdata->pages[i];
3465                 size_t n;
3466                 unsigned int segment_size = rdata->pagesz;
3467
3468                 if (i == 0)
3469                         segment_size -= page_offset;
3470                 else
3471                         page_offset = 0;
3472
3473
3474                 if (len <= 0) {
3475                         /* no need to hold page hostage */
3476                         rdata->pages[i] = NULL;
3477                         rdata->nr_pages--;
3478                         put_page(page);
3479                         continue;
3480                 }
3481
3482                 n = len;
3483                 if (len >= segment_size)
3484                         /* enough data to fill the page */
3485                         n = segment_size;
3486                 else
3487                         rdata->tailsz = len;
3488                 len -= n;
3489
3490                 if (iter)
3491                         result = copy_page_from_iter(
3492                                         page, page_offset, n, iter);
3493 #ifdef CONFIG_CIFS_SMB_DIRECT
3494                 else if (rdata->mr)
3495                         result = n;
3496 #endif
3497                 else
3498                         result = cifs_read_page_from_socket(
3499                                         server, page, page_offset, n);
3500                 if (result < 0)
3501                         break;
3502
3503                 rdata->got_bytes += result;
3504         }
3505
3506         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3507                                                 rdata->got_bytes : result;
3508 }
3509
3510 static int
3511 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3512                               struct cifs_readdata *rdata, unsigned int len)
3513 {
3514         return uncached_fill_pages(server, rdata, NULL, len);
3515 }
3516
3517 static int
3518 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3519                               struct cifs_readdata *rdata,
3520                               struct iov_iter *iter)
3521 {
3522         return uncached_fill_pages(server, rdata, iter, iter->count);
3523 }
3524
3525 static int cifs_resend_rdata(struct cifs_readdata *rdata,
3526                         struct list_head *rdata_list,
3527                         struct cifs_aio_ctx *ctx)
3528 {
3529         unsigned int rsize;
3530         struct cifs_credits credits;
3531         int rc;
3532         struct TCP_Server_Info *server =
3533                 tlink_tcon(rdata->cfile->tlink)->ses->server;
3534
3535         do {
3536                 if (rdata->cfile->invalidHandle) {
3537                         rc = cifs_reopen_file(rdata->cfile, true);
3538                         if (rc == -EAGAIN)
3539                                 continue;
3540                         else if (rc)
3541                                 break;
3542                 }
3543
3544                 /*
3545                  * Wait for credits to resend this rdata.
3546                  * Note: we are attempting to resend the whole rdata not in
3547                  * segments
3548                  */
3549                 do {
3550                         rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3551                                                 &rsize, &credits);
3552
3553                         if (rc)
3554                                 goto fail;
3555
3556                         if (rsize < rdata->bytes) {
3557                                 add_credits_and_wake_if(server, &credits, 0);
3558                                 msleep(1000);
3559                         }
3560                 } while (rsize < rdata->bytes);
3561                 rdata->credits = credits;
3562
3563                 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3564                 if (!rc) {
3565                         if (rdata->cfile->invalidHandle)
3566                                 rc = -EAGAIN;
3567                         else {
3568 #ifdef CONFIG_CIFS_SMB_DIRECT
3569                                 if (rdata->mr) {
3570                                         rdata->mr->need_invalidate = true;
3571                                         smbd_deregister_mr(rdata->mr);
3572                                         rdata->mr = NULL;
3573                                 }
3574 #endif
3575                                 rc = server->ops->async_readv(rdata);
3576                         }
3577                 }
3578
3579                 /* If the read was successfully sent, we are done */
3580                 if (!rc) {
3581                         /* Add to aio pending list */
3582                         list_add_tail(&rdata->list, rdata_list);
3583                         return 0;
3584                 }
3585
3586                 /* Roll back credits and retry if needed */
3587                 add_credits_and_wake_if(server, &rdata->credits, 0);
3588         } while (rc == -EAGAIN);
3589
3590 fail:
3591         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3592         return rc;
3593 }
3594
3595 static int
3596 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3597                      struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3598                      struct cifs_aio_ctx *ctx)
3599 {
3600         struct cifs_readdata *rdata;
3601         unsigned int npages, rsize;
3602         struct cifs_credits credits_on_stack;
3603         struct cifs_credits *credits = &credits_on_stack;
3604         size_t cur_len;
3605         int rc;
3606         pid_t pid;
3607         struct TCP_Server_Info *server;
3608         struct page **pagevec;
3609         size_t start;
3610         struct iov_iter direct_iov = ctx->iter;
3611
3612         server = tlink_tcon(open_file->tlink)->ses->server;
3613
3614         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3615                 pid = open_file->pid;
3616         else
3617                 pid = current->tgid;
3618
3619         if (ctx->direct_io)
3620                 iov_iter_advance(&direct_iov, offset - ctx->pos);
3621
3622         do {
3623                 if (open_file->invalidHandle) {
3624                         rc = cifs_reopen_file(open_file, true);
3625                         if (rc == -EAGAIN)
3626                                 continue;
3627                         else if (rc)
3628                                 break;
3629                 }
3630
3631                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3632                                                    &rsize, credits);
3633                 if (rc)
3634                         break;
3635
3636                 cur_len = min_t(const size_t, len, rsize);
3637
3638                 if (ctx->direct_io) {
3639                         ssize_t result;
3640
3641                         result = iov_iter_get_pages_alloc(
3642                                         &direct_iov, &pagevec,
3643                                         cur_len, &start);
3644                         if (result < 0) {
3645                                 cifs_dbg(VFS,
3646                                         "couldn't get user pages (rc=%zd)"
3647                                         " iter type %d"
3648                                         " iov_offset %zd count %zd\n",
3649                                         result, iov_iter_type(&direct_iov),
3650                                         direct_iov.iov_offset,
3651                                         direct_iov.count);
3652                                 dump_stack();
3653
3654                                 rc = result;
3655                                 add_credits_and_wake_if(server, credits, 0);
3656                                 break;
3657                         }
3658                         cur_len = (size_t)result;
3659                         iov_iter_advance(&direct_iov, cur_len);
3660
3661                         rdata = cifs_readdata_direct_alloc(
3662                                         pagevec, cifs_uncached_readv_complete);
3663                         if (!rdata) {
3664                                 add_credits_and_wake_if(server, credits, 0);
3665                                 rc = -ENOMEM;
3666                                 break;
3667                         }
3668
3669                         npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
3670                         rdata->page_offset = start;
3671                         rdata->tailsz = npages > 1 ?
3672                                 cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
3673                                 cur_len;
3674
3675                 } else {
3676
3677                         npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3678                         /* allocate a readdata struct */
3679                         rdata = cifs_readdata_alloc(npages,
3680                                             cifs_uncached_readv_complete);
3681                         if (!rdata) {
3682                                 add_credits_and_wake_if(server, credits, 0);
3683                                 rc = -ENOMEM;
3684                                 break;
3685                         }
3686
3687                         rc = cifs_read_allocate_pages(rdata, npages);
3688                         if (rc) {
3689                                 kvfree(rdata->pages);
3690                                 kfree(rdata);
3691                                 add_credits_and_wake_if(server, credits, 0);
3692                                 break;
3693                         }
3694
3695                         rdata->tailsz = PAGE_SIZE;
3696                 }
3697
3698                 rdata->cfile = cifsFileInfo_get(open_file);
3699                 rdata->nr_pages = npages;
3700                 rdata->offset = offset;
3701                 rdata->bytes = cur_len;
3702                 rdata->pid = pid;
3703                 rdata->pagesz = PAGE_SIZE;
3704                 rdata->read_into_pages = cifs_uncached_read_into_pages;
3705                 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3706                 rdata->credits = credits_on_stack;
3707                 rdata->ctx = ctx;
3708                 kref_get(&ctx->refcount);
3709
3710                 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3711
3712                 if (!rc) {
3713                         if (rdata->cfile->invalidHandle)
3714                                 rc = -EAGAIN;
3715                         else
3716                                 rc = server->ops->async_readv(rdata);
3717                 }
3718
3719                 if (rc) {
3720                         add_credits_and_wake_if(server, &rdata->credits, 0);
3721                         kref_put(&rdata->refcount,
3722                                 cifs_uncached_readdata_release);
3723                         if (rc == -EAGAIN) {
3724                                 iov_iter_revert(&direct_iov, cur_len);
3725                                 continue;
3726                         }
3727                         break;
3728                 }
3729
3730                 list_add_tail(&rdata->list, rdata_list);
3731                 offset += cur_len;
3732                 len -= cur_len;
3733         } while (len > 0);
3734
3735         return rc;
3736 }
3737
3738 static void
3739 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3740 {
3741         struct cifs_readdata *rdata, *tmp;
3742         struct iov_iter *to = &ctx->iter;
3743         struct cifs_sb_info *cifs_sb;
3744         int rc;
3745
3746         cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3747
3748         mutex_lock(&ctx->aio_mutex);
3749
3750         if (list_empty(&ctx->list)) {
3751                 mutex_unlock(&ctx->aio_mutex);
3752                 return;
3753         }
3754
3755         rc = ctx->rc;
3756         /* the loop below should proceed in the order of increasing offsets */
3757 again:
3758         list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3759                 if (!rc) {
3760                         if (!try_wait_for_completion(&rdata->done)) {
3761                                 mutex_unlock(&ctx->aio_mutex);
3762                                 return;
3763                         }
3764
3765                         if (rdata->result == -EAGAIN) {
3766                                 /* resend call if it's a retryable error */
3767                                 struct list_head tmp_list;
3768                                 unsigned int got_bytes = rdata->got_bytes;
3769
3770                                 list_del_init(&rdata->list);
3771                                 INIT_LIST_HEAD(&tmp_list);
3772
3773                                 /*
3774                                  * Got a part of data and then reconnect has
3775                                  * happened -- fill the buffer and continue
3776                                  * reading.
3777                                  */
3778                                 if (got_bytes && got_bytes < rdata->bytes) {
3779                                         rc = 0;
3780                                         if (!ctx->direct_io)
3781                                                 rc = cifs_readdata_to_iov(rdata, to);
3782                                         if (rc) {
3783                                                 kref_put(&rdata->refcount,
3784                                                         cifs_uncached_readdata_release);
3785                                                 continue;
3786                                         }
3787                                 }
3788
3789                                 if (ctx->direct_io) {
3790                                         /*
3791                                          * Re-use rdata as this is a
3792                                          * direct I/O
3793                                          */
3794                                         rc = cifs_resend_rdata(
3795                                                 rdata,
3796                                                 &tmp_list, ctx);
3797                                 } else {
3798                                         rc = cifs_send_async_read(
3799                                                 rdata->offset + got_bytes,
3800                                                 rdata->bytes - got_bytes,
3801                                                 rdata->cfile, cifs_sb,
3802                                                 &tmp_list, ctx);
3803
3804                                         kref_put(&rdata->refcount,
3805                                                 cifs_uncached_readdata_release);
3806                                 }
3807
3808                                 list_splice(&tmp_list, &ctx->list);
3809
3810                                 goto again;
3811                         } else if (rdata->result)
3812                                 rc = rdata->result;
3813                         else if (!ctx->direct_io)
3814                                 rc = cifs_readdata_to_iov(rdata, to);
3815
3816                         /* if there was a short read -- discard anything left */
3817                         if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3818                                 rc = -ENODATA;
3819
3820                         ctx->total_len += rdata->got_bytes;
3821                 }
3822                 list_del_init(&rdata->list);
3823                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3824         }
3825
3826         if (!ctx->direct_io)
3827                 ctx->total_len = ctx->len - iov_iter_count(to);
3828
3829         /* mask nodata case */
3830         if (rc == -ENODATA)
3831                 rc = 0;
3832
3833         ctx->rc = (rc == 0) ? ctx->total_len : rc;
3834
3835         mutex_unlock(&ctx->aio_mutex);
3836
3837         if (ctx->iocb && ctx->iocb->ki_complete)
3838                 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3839         else
3840                 complete(&ctx->done);
3841 }
3842
3843 static ssize_t __cifs_readv(
3844         struct kiocb *iocb, struct iov_iter *to, bool direct)
3845 {
3846         size_t len;
3847         struct file *file = iocb->ki_filp;
3848         struct cifs_sb_info *cifs_sb;
3849         struct cifsFileInfo *cfile;
3850         struct cifs_tcon *tcon;
3851         ssize_t rc, total_read = 0;
3852         loff_t offset = iocb->ki_pos;
3853         struct cifs_aio_ctx *ctx;
3854
3855         /*
3856          * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3857          * fall back to data copy read path
3858          * this could be improved by getting pages directly in ITER_KVEC
3859          */
3860         if (direct && iov_iter_is_kvec(to)) {
3861                 cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
3862                 direct = false;
3863         }
3864
3865         len = iov_iter_count(to);
3866         if (!len)
3867                 return 0;
3868
3869         cifs_sb = CIFS_FILE_SB(file);
3870         cfile = file->private_data;
3871         tcon = tlink_tcon(cfile->tlink);
3872
3873         if (!tcon->ses->server->ops->async_readv)
3874                 return -ENOSYS;
3875
3876         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3877                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3878
3879         ctx = cifs_aio_ctx_alloc();
3880         if (!ctx)
3881                 return -ENOMEM;
3882
3883         ctx->cfile = cifsFileInfo_get(cfile);
3884
3885         if (!is_sync_kiocb(iocb))
3886                 ctx->iocb = iocb;
3887
3888         if (iter_is_iovec(to))
3889                 ctx->should_dirty = true;
3890
3891         if (direct) {
3892                 ctx->pos = offset;
3893                 ctx->direct_io = true;
3894                 ctx->iter = *to;
3895                 ctx->len = len;
3896         } else {
3897                 rc = setup_aio_ctx_iter(ctx, to, READ);
3898                 if (rc) {
3899                         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3900                         return rc;
3901                 }
3902                 len = ctx->len;
3903         }
3904
3905         /* grab a lock here due to read response handlers can access ctx */
3906         mutex_lock(&ctx->aio_mutex);
3907
3908         rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3909
3910         /* if at least one read request send succeeded, then reset rc */
3911         if (!list_empty(&ctx->list))
3912                 rc = 0;
3913
3914         mutex_unlock(&ctx->aio_mutex);
3915
3916         if (rc) {
3917                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3918                 return rc;
3919         }
3920
3921         if (!is_sync_kiocb(iocb)) {
3922                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3923                 return -EIOCBQUEUED;
3924         }
3925
3926         rc = wait_for_completion_killable(&ctx->done);
3927         if (rc) {
3928                 mutex_lock(&ctx->aio_mutex);
3929                 ctx->rc = rc = -EINTR;
3930                 total_read = ctx->total_len;
3931                 mutex_unlock(&ctx->aio_mutex);
3932         } else {
3933                 rc = ctx->rc;
3934                 total_read = ctx->total_len;
3935         }
3936
3937         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3938
3939         if (total_read) {
3940                 iocb->ki_pos += total_read;
3941                 return total_read;
3942         }
3943         return rc;
3944 }
3945
3946 ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
3947 {
3948         return __cifs_readv(iocb, to, true);
3949 }
3950
3951 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3952 {
3953         return __cifs_readv(iocb, to, false);
3954 }
3955
3956 ssize_t
3957 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3958 {
3959         struct inode *inode = file_inode(iocb->ki_filp);
3960         struct cifsInodeInfo *cinode = CIFS_I(inode);
3961         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3962         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3963                                                 iocb->ki_filp->private_data;
3964         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3965         int rc = -EACCES;
3966
3967         /*
3968          * In strict cache mode we need to read from the server all the time
3969          * if we don't have level II oplock because the server can delay mtime
3970          * change - so we can't make a decision about inode invalidating.
3971          * And we can also fail with pagereading if there are mandatory locks
3972          * on pages affected by this read but not on the region from pos to
3973          * pos+len-1.
3974          */
3975         if (!CIFS_CACHE_READ(cinode))
3976                 return cifs_user_readv(iocb, to);
3977
3978         if (cap_unix(tcon->ses) &&
3979             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3980             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3981                 return generic_file_read_iter(iocb, to);
3982
3983         /*
3984          * We need to hold the sem to be sure nobody modifies lock list
3985          * with a brlock that prevents reading.
3986          */
3987         down_read(&cinode->lock_sem);
3988         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3989                                      tcon->ses->server->vals->shared_lock_type,
3990                                      0, NULL, CIFS_READ_OP))
3991                 rc = generic_file_read_iter(iocb, to);
3992         up_read(&cinode->lock_sem);
3993         return rc;
3994 }
3995
3996 static ssize_t
3997 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3998 {
3999         int rc = -EACCES;
4000         unsigned int bytes_read = 0;
4001         unsigned int total_read;
4002         unsigned int current_read_size;
4003         unsigned int rsize;
4004         struct cifs_sb_info *cifs_sb;
4005         struct cifs_tcon *tcon;
4006         struct TCP_Server_Info *server;
4007         unsigned int xid;
4008         char *cur_offset;
4009         struct cifsFileInfo *open_file;
4010         struct cifs_io_parms io_parms;
4011         int buf_type = CIFS_NO_BUFFER;
4012         __u32 pid;
4013
4014         xid = get_xid();
4015         cifs_sb = CIFS_FILE_SB(file);
4016
4017         /* FIXME: set up handlers for larger reads and/or convert to async */
4018         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
4019
4020         if (file->private_data == NULL) {
4021                 rc = -EBADF;
4022                 free_xid(xid);
4023                 return rc;
4024         }
4025         open_file = file->private_data;
4026         tcon = tlink_tcon(open_file->tlink);
4027         server = tcon->ses->server;
4028
4029         if (!server->ops->sync_read) {
4030                 free_xid(xid);
4031                 return -ENOSYS;
4032         }
4033
4034         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4035                 pid = open_file->pid;
4036         else
4037                 pid = current->tgid;
4038
4039         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
4040                 cifs_dbg(FYI, "attempting read on write only file instance\n");
4041
4042         for (total_read = 0, cur_offset = read_data; read_size > total_read;
4043              total_read += bytes_read, cur_offset += bytes_read) {
4044                 do {
4045                         current_read_size = min_t(uint, read_size - total_read,
4046                                                   rsize);
4047                         /*
4048                          * For windows me and 9x we do not want to request more
4049                          * than it negotiated since it will refuse the read
4050                          * then.
4051                          */
4052                         if ((tcon->ses) && !(tcon->ses->capabilities &
4053                                 tcon->ses->server->vals->cap_large_files)) {
4054                                 current_read_size = min_t(uint,
4055                                         current_read_size, CIFSMaxBufSize);
4056                         }
4057                         if (open_file->invalidHandle) {
4058                                 rc = cifs_reopen_file(open_file, true);
4059                                 if (rc != 0)
4060                                         break;
4061                         }
4062                         io_parms.pid = pid;
4063                         io_parms.tcon = tcon;
4064                         io_parms.offset = *offset;
4065                         io_parms.length = current_read_size;
4066                         rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
4067                                                     &bytes_read, &cur_offset,
4068                                                     &buf_type);
4069                 } while (rc == -EAGAIN);
4070
4071                 if (rc || (bytes_read == 0)) {
4072                         if (total_read) {
4073                                 break;
4074                         } else {
4075                                 free_xid(xid);
4076                                 return rc;
4077                         }
4078                 } else {
4079                         cifs_stats_bytes_read(tcon, total_read);
4080                         *offset += bytes_read;
4081                 }
4082         }
4083         free_xid(xid);
4084         return total_read;
4085 }
4086
4087 /*
4088  * If the page is mmap'ed into a process' page tables, then we need to make
4089  * sure that it doesn't change while being written back.
4090  */
4091 static vm_fault_t
4092 cifs_page_mkwrite(struct vm_fault *vmf)
4093 {
4094         struct page *page = vmf->page;
4095
4096         lock_page(page);
4097         return VM_FAULT_LOCKED;
4098 }
4099
4100 static const struct vm_operations_struct cifs_file_vm_ops = {
4101         .fault = filemap_fault,
4102         .map_pages = filemap_map_pages,
4103         .page_mkwrite = cifs_page_mkwrite,
4104 };
4105
4106 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
4107 {
4108         int xid, rc = 0;
4109         struct inode *inode = file_inode(file);
4110
4111         xid = get_xid();
4112
4113         if (!CIFS_CACHE_READ(CIFS_I(inode)))
4114                 rc = cifs_zap_mapping(inode);
4115         if (!rc)
4116                 rc = generic_file_mmap(file, vma);
4117         if (!rc)
4118                 vma->vm_ops = &cifs_file_vm_ops;
4119
4120         free_xid(xid);
4121         return rc;
4122 }
4123
4124 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
4125 {
4126         int rc, xid;
4127
4128         xid = get_xid();
4129
4130         rc = cifs_revalidate_file(file);
4131         if (rc)
4132                 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
4133                          rc);
4134         if (!rc)
4135                 rc = generic_file_mmap(file, vma);
4136         if (!rc)
4137                 vma->vm_ops = &cifs_file_vm_ops;
4138
4139         free_xid(xid);
4140         return rc;
4141 }
4142
4143 static void
4144 cifs_readv_complete(struct work_struct *work)
4145 {
4146         unsigned int i, got_bytes;
4147         struct cifs_readdata *rdata = container_of(work,
4148                                                 struct cifs_readdata, work);
4149
4150         got_bytes = rdata->got_bytes;
4151         for (i = 0; i < rdata->nr_pages; i++) {
4152                 struct page *page = rdata->pages[i];
4153
4154                 lru_cache_add_file(page);
4155
4156                 if (rdata->result == 0 ||
4157                     (rdata->result == -EAGAIN && got_bytes)) {
4158                         flush_dcache_page(page);
4159                         SetPageUptodate(page);
4160                 }
4161
4162                 unlock_page(page);
4163
4164                 if (rdata->result == 0 ||
4165                     (rdata->result == -EAGAIN && got_bytes))
4166                         cifs_readpage_to_fscache(rdata->mapping->host, page);
4167
4168                 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4169
4170                 put_page(page);
4171                 rdata->pages[i] = NULL;
4172         }
4173         kref_put(&rdata->refcount, cifs_readdata_release);
4174 }
4175
4176 static int
4177 readpages_fill_pages(struct TCP_Server_Info *server,
4178                      struct cifs_readdata *rdata, struct iov_iter *iter,
4179                      unsigned int len)
4180 {
4181         int result = 0;
4182         unsigned int i;
4183         u64 eof;
4184         pgoff_t eof_index;
4185         unsigned int nr_pages = rdata->nr_pages;
4186         unsigned int page_offset = rdata->page_offset;
4187
4188         /* determine the eof that the server (probably) has */
4189         eof = CIFS_I(rdata->mapping->host)->server_eof;
4190         eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4191         cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4192
4193         rdata->got_bytes = 0;
4194         rdata->tailsz = PAGE_SIZE;
4195         for (i = 0; i < nr_pages; i++) {
4196                 struct page *page = rdata->pages[i];
4197                 unsigned int to_read = rdata->pagesz;
4198                 size_t n;
4199
4200                 if (i == 0)
4201                         to_read -= page_offset;
4202                 else
4203                         page_offset = 0;
4204
4205                 n = to_read;
4206
4207                 if (len >= to_read) {
4208                         len -= to_read;
4209                 } else if (len > 0) {
4210                         /* enough for partial page, fill and zero the rest */
4211                         zero_user(page, len + page_offset, to_read - len);
4212                         n = rdata->tailsz = len;
4213                         len = 0;
4214                 } else if (page->index > eof_index) {
4215                         /*
4216                          * The VFS will not try to do readahead past the
4217                          * i_size, but it's possible that we have outstanding
4218                          * writes with gaps in the middle and the i_size hasn't
4219                          * caught up yet. Populate those with zeroed out pages
4220                          * to prevent the VFS from repeatedly attempting to
4221                          * fill them until the writes are flushed.
4222                          */
4223                         zero_user(page, 0, PAGE_SIZE);
4224                         lru_cache_add_file(page);
4225                         flush_dcache_page(page);
4226                         SetPageUptodate(page);
4227                         unlock_page(page);
4228                         put_page(page);
4229                         rdata->pages[i] = NULL;
4230                         rdata->nr_pages--;
4231                         continue;
4232                 } else {
4233                         /* no need to hold page hostage */
4234                         lru_cache_add_file(page);
4235                         unlock_page(page);
4236                         put_page(page);
4237                         rdata->pages[i] = NULL;
4238                         rdata->nr_pages--;
4239                         continue;
4240                 }
4241
4242                 if (iter)
4243                         result = copy_page_from_iter(
4244                                         page, page_offset, n, iter);
4245 #ifdef CONFIG_CIFS_SMB_DIRECT
4246                 else if (rdata->mr)
4247                         result = n;
4248 #endif
4249                 else
4250                         result = cifs_read_page_from_socket(
4251                                         server, page, page_offset, n);
4252                 if (result < 0)
4253                         break;
4254
4255                 rdata->got_bytes += result;
4256         }
4257
4258         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
4259                                                 rdata->got_bytes : result;
4260 }
4261
4262 static int
4263 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4264                                struct cifs_readdata *rdata, unsigned int len)
4265 {
4266         return readpages_fill_pages(server, rdata, NULL, len);
4267 }
4268
4269 static int
4270 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4271                                struct cifs_readdata *rdata,
4272                                struct iov_iter *iter)
4273 {
4274         return readpages_fill_pages(server, rdata, iter, iter->count);
4275 }
4276
4277 static int
4278 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
4279                     unsigned int rsize, struct list_head *tmplist,
4280                     unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
4281 {
4282         struct page *page, *tpage;
4283         unsigned int expected_index;
4284         int rc;
4285         gfp_t gfp = readahead_gfp_mask(mapping);
4286
4287         INIT_LIST_HEAD(tmplist);
4288
4289         page = lru_to_page(page_list);
4290
4291         /*
4292          * Lock the page and put it in the cache. Since no one else
4293          * should have access to this page, we're safe to simply set
4294          * PG_locked without checking it first.
4295          */
4296         __SetPageLocked(page);
4297         rc = add_to_page_cache_locked(page, mapping,
4298                                       page->index, gfp);
4299
4300         /* give up if we can't stick it in the cache */
4301         if (rc) {
4302                 __ClearPageLocked(page);
4303                 return rc;
4304         }
4305
4306         /* move first page to the tmplist */
4307         *offset = (loff_t)page->index << PAGE_SHIFT;
4308         *bytes = PAGE_SIZE;
4309         *nr_pages = 1;
4310         list_move_tail(&page->lru, tmplist);
4311
4312         /* now try and add more pages onto the request */
4313         expected_index = page->index + 1;
4314         list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4315                 /* discontinuity ? */
4316                 if (page->index != expected_index)
4317                         break;
4318
4319                 /* would this page push the read over the rsize? */
4320                 if (*bytes + PAGE_SIZE > rsize)
4321                         break;
4322
4323                 __SetPageLocked(page);
4324                 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
4325                         __ClearPageLocked(page);
4326                         break;
4327                 }
4328                 list_move_tail(&page->lru, tmplist);
4329                 (*bytes) += PAGE_SIZE;
4330                 expected_index++;
4331                 (*nr_pages)++;
4332         }
4333         return rc;
4334 }
4335
4336 static int cifs_readpages(struct file *file, struct address_space *mapping,
4337         struct list_head *page_list, unsigned num_pages)
4338 {
4339         int rc;
4340         struct list_head tmplist;
4341         struct cifsFileInfo *open_file = file->private_data;
4342         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4343         struct TCP_Server_Info *server;
4344         pid_t pid;
4345         unsigned int xid;
4346
4347         xid = get_xid();
4348         /*
4349          * Reads as many pages as possible from fscache. Returns -ENOBUFS
4350          * immediately if the cookie is negative
4351          *
4352          * After this point, every page in the list might have PG_fscache set,
4353          * so we will need to clean that up off of every page we don't use.
4354          */
4355         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4356                                          &num_pages);
4357         if (rc == 0) {
4358                 free_xid(xid);
4359                 return rc;
4360         }
4361
4362         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4363                 pid = open_file->pid;
4364         else
4365                 pid = current->tgid;
4366
4367         rc = 0;
4368         server = tlink_tcon(open_file->tlink)->ses->server;
4369
4370         cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4371                  __func__, file, mapping, num_pages);
4372
4373         /*
4374          * Start with the page at end of list and move it to private
4375          * list. Do the same with any following pages until we hit
4376          * the rsize limit, hit an index discontinuity, or run out of
4377          * pages. Issue the async read and then start the loop again
4378          * until the list is empty.
4379          *
4380          * Note that list order is important. The page_list is in
4381          * the order of declining indexes. When we put the pages in
4382          * the rdata->pages, then we want them in increasing order.
4383          */
4384         while (!list_empty(page_list)) {
4385                 unsigned int i, nr_pages, bytes, rsize;
4386                 loff_t offset;
4387                 struct page *page, *tpage;
4388                 struct cifs_readdata *rdata;
4389                 struct cifs_credits credits_on_stack;
4390                 struct cifs_credits *credits = &credits_on_stack;
4391
4392                 if (open_file->invalidHandle) {
4393                         rc = cifs_reopen_file(open_file, true);
4394                         if (rc == -EAGAIN)
4395                                 continue;
4396                         else if (rc)
4397                                 break;
4398                 }
4399
4400                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
4401                                                    &rsize, credits);
4402                 if (rc)
4403                         break;
4404
4405                 /*
4406                  * Give up immediately if rsize is too small to read an entire
4407                  * page. The VFS will fall back to readpage. We should never
4408                  * reach this point however since we set ra_pages to 0 when the
4409                  * rsize is smaller than a cache page.
4410                  */
4411                 if (unlikely(rsize < PAGE_SIZE)) {
4412                         add_credits_and_wake_if(server, credits, 0);
4413                         free_xid(xid);
4414                         return 0;
4415                 }
4416
4417                 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4418                                          &nr_pages, &offset, &bytes);
4419                 if (rc) {
4420                         add_credits_and_wake_if(server, credits, 0);
4421                         break;
4422                 }
4423
4424                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4425                 if (!rdata) {
4426                         /* best to give up if we're out of mem */
4427                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4428                                 list_del(&page->lru);
4429                                 lru_cache_add_file(page);
4430                                 unlock_page(page);
4431                                 put_page(page);
4432                         }
4433                         rc = -ENOMEM;
4434                         add_credits_and_wake_if(server, credits, 0);
4435                         break;
4436                 }
4437
4438                 rdata->cfile = cifsFileInfo_get(open_file);
4439                 rdata->mapping = mapping;
4440                 rdata->offset = offset;
4441                 rdata->bytes = bytes;
4442                 rdata->pid = pid;
4443                 rdata->pagesz = PAGE_SIZE;
4444                 rdata->tailsz = PAGE_SIZE;
4445                 rdata->read_into_pages = cifs_readpages_read_into_pages;
4446                 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4447                 rdata->credits = credits_on_stack;
4448
4449                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4450                         list_del(&page->lru);
4451                         rdata->pages[rdata->nr_pages++] = page;
4452                 }
4453
4454                 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4455
4456                 if (!rc) {
4457                         if (rdata->cfile->invalidHandle)
4458                                 rc = -EAGAIN;
4459                         else
4460                                 rc = server->ops->async_readv(rdata);
4461                 }
4462
4463                 if (rc) {
4464                         add_credits_and_wake_if(server, &rdata->credits, 0);
4465                         for (i = 0; i < rdata->nr_pages; i++) {
4466                                 page = rdata->pages[i];
4467                                 lru_cache_add_file(page);
4468                                 unlock_page(page);
4469                                 put_page(page);
4470                         }
4471                         /* Fallback to the readpage in error/reconnect cases */
4472                         kref_put(&rdata->refcount, cifs_readdata_release);
4473                         break;
4474                 }
4475
4476                 kref_put(&rdata->refcount, cifs_readdata_release);
4477         }
4478
4479         /* Any pages that have been shown to fscache but didn't get added to
4480          * the pagecache must be uncached before they get returned to the
4481          * allocator.
4482          */
4483         cifs_fscache_readpages_cancel(mapping->host, page_list);
4484         free_xid(xid);
4485         return rc;
4486 }
4487
4488 /*
4489  * cifs_readpage_worker must be called with the page pinned
4490  */
4491 static int cifs_readpage_worker(struct file *file, struct page *page,
4492         loff_t *poffset)
4493 {
4494         char *read_data;
4495         int rc;
4496
4497         /* Is the page cached? */
4498         rc = cifs_readpage_from_fscache(file_inode(file), page);
4499         if (rc == 0)
4500                 goto read_complete;
4501
4502         read_data = kmap(page);
4503         /* for reads over a certain size could initiate async read ahead */
4504
4505         rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4506
4507         if (rc < 0)
4508                 goto io_error;
4509         else
4510                 cifs_dbg(FYI, "Bytes read %d\n", rc);
4511
4512         /* we do not want atime to be less than mtime, it broke some apps */
4513         file_inode(file)->i_atime = current_time(file_inode(file));
4514         if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4515                 file_inode(file)->i_atime = file_inode(file)->i_mtime;
4516         else
4517                 file_inode(file)->i_atime = current_time(file_inode(file));
4518
4519         if (PAGE_SIZE > rc)
4520                 memset(read_data + rc, 0, PAGE_SIZE - rc);
4521
4522         flush_dcache_page(page);
4523         SetPageUptodate(page);
4524
4525         /* send this page to the cache */
4526         cifs_readpage_to_fscache(file_inode(file), page);
4527
4528         rc = 0;
4529
4530 io_error:
4531         kunmap(page);
4532         unlock_page(page);
4533
4534 read_complete:
4535         return rc;
4536 }
4537
4538 static int cifs_readpage(struct file *file, struct page *page)
4539 {
4540         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
4541         int rc = -EACCES;
4542         unsigned int xid;
4543
4544         xid = get_xid();
4545
4546         if (file->private_data == NULL) {
4547                 rc = -EBADF;
4548                 free_xid(xid);
4549                 return rc;
4550         }
4551
4552         cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4553                  page, (int)offset, (int)offset);
4554
4555         rc = cifs_readpage_worker(file, page, &offset);
4556
4557         free_xid(xid);
4558         return rc;
4559 }
4560
4561 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4562 {
4563         struct cifsFileInfo *open_file;
4564
4565         spin_lock(&cifs_inode->open_file_lock);
4566         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4567                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4568                         spin_unlock(&cifs_inode->open_file_lock);
4569                         return 1;
4570                 }
4571         }
4572         spin_unlock(&cifs_inode->open_file_lock);
4573         return 0;
4574 }
4575
4576 /* We do not want to update the file size from server for inodes
4577    open for write - to avoid races with writepage extending
4578    the file - in the future we could consider allowing
4579    refreshing the inode only on increases in the file size
4580    but this is tricky to do without racing with writebehind
4581    page caching in the current Linux kernel design */
4582 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4583 {
4584         if (!cifsInode)
4585                 return true;
4586
4587         if (is_inode_writable(cifsInode)) {
4588                 /* This inode is open for write at least once */
4589                 struct cifs_sb_info *cifs_sb;
4590
4591                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
4592                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4593                         /* since no page cache to corrupt on directio
4594                         we can change size safely */
4595                         return true;
4596                 }
4597
4598                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4599                         return true;
4600
4601                 return false;
4602         } else
4603                 return true;
4604 }
4605
4606 static int cifs_write_begin(struct file *file, struct address_space *mapping,
4607                         loff_t pos, unsigned len, unsigned flags,
4608                         struct page **pagep, void **fsdata)
4609 {
4610         int oncethru = 0;
4611         pgoff_t index = pos >> PAGE_SHIFT;
4612         loff_t offset = pos & (PAGE_SIZE - 1);
4613         loff_t page_start = pos & PAGE_MASK;
4614         loff_t i_size;
4615         struct page *page;
4616         int rc = 0;
4617
4618         cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4619
4620 start:
4621         page = grab_cache_page_write_begin(mapping, index, flags);
4622         if (!page) {
4623                 rc = -ENOMEM;
4624                 goto out;
4625         }
4626
4627         if (PageUptodate(page))
4628                 goto out;
4629
4630         /*
4631          * If we write a full page it will be up to date, no need to read from
4632          * the server. If the write is short, we'll end up doing a sync write
4633          * instead.
4634          */
4635         if (len == PAGE_SIZE)
4636                 goto out;
4637
4638         /*
4639          * optimize away the read when we have an oplock, and we're not
4640          * expecting to use any of the data we'd be reading in. That
4641          * is, when the page lies beyond the EOF, or straddles the EOF
4642          * and the write will cover all of the existing data.
4643          */
4644         if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4645                 i_size = i_size_read(mapping->host);
4646                 if (page_start >= i_size ||
4647                     (offset == 0 && (pos + len) >= i_size)) {
4648                         zero_user_segments(page, 0, offset,
4649                                            offset + len,
4650                                            PAGE_SIZE);
4651                         /*
4652                          * PageChecked means that the parts of the page
4653                          * to which we're not writing are considered up
4654                          * to date. Once the data is copied to the
4655                          * page, it can be set uptodate.
4656                          */
4657                         SetPageChecked(page);
4658                         goto out;
4659                 }
4660         }
4661
4662         if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4663                 /*
4664                  * might as well read a page, it is fast enough. If we get
4665                  * an error, we don't need to return it. cifs_write_end will
4666                  * do a sync write instead since PG_uptodate isn't set.
4667                  */
4668                 cifs_readpage_worker(file, page, &page_start);
4669                 put_page(page);
4670                 oncethru = 1;
4671                 goto start;
4672         } else {
4673                 /* we could try using another file handle if there is one -
4674                    but how would we lock it to prevent close of that handle
4675                    racing with this read? In any case
4676                    this will be written out by write_end so is fine */
4677         }
4678 out:
4679         *pagep = page;
4680         return rc;
4681 }
4682
4683 static int cifs_release_page(struct page *page, gfp_t gfp)
4684 {
4685         if (PagePrivate(page))
4686                 return 0;
4687
4688         return cifs_fscache_release_page(page, gfp);
4689 }
4690
4691 static void cifs_invalidate_page(struct page *page, unsigned int offset,
4692                                  unsigned int length)
4693 {
4694         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4695
4696         if (offset == 0 && length == PAGE_SIZE)
4697                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4698 }
4699
4700 static int cifs_launder_page(struct page *page)
4701 {
4702         int rc = 0;
4703         loff_t range_start = page_offset(page);
4704         loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4705         struct writeback_control wbc = {
4706                 .sync_mode = WB_SYNC_ALL,
4707                 .nr_to_write = 0,
4708                 .range_start = range_start,
4709                 .range_end = range_end,
4710         };
4711
4712         cifs_dbg(FYI, "Launder page: %p\n", page);
4713
4714         if (clear_page_dirty_for_io(page))
4715                 rc = cifs_writepage_locked(page, &wbc);
4716
4717         cifs_fscache_invalidate_page(page, page->mapping->host);
4718         return rc;
4719 }
4720
4721 void cifs_oplock_break(struct work_struct *work)
4722 {
4723         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4724                                                   oplock_break);
4725         struct inode *inode = d_inode(cfile->dentry);
4726         struct cifsInodeInfo *cinode = CIFS_I(inode);
4727         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4728         struct TCP_Server_Info *server = tcon->ses->server;
4729         int rc = 0;
4730         bool purge_cache = false;
4731
4732         wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4733                         TASK_UNINTERRUPTIBLE);
4734
4735         server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,
4736                                       cfile->oplock_epoch, &purge_cache);
4737
4738         if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4739                                                 cifs_has_mand_locks(cinode)) {
4740                 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4741                          inode);
4742                 cinode->oplock = 0;
4743         }
4744
4745         if (inode && S_ISREG(inode->i_mode)) {
4746                 if (CIFS_CACHE_READ(cinode))
4747                         break_lease(inode, O_RDONLY);
4748                 else
4749                         break_lease(inode, O_WRONLY);
4750                 rc = filemap_fdatawrite(inode->i_mapping);
4751                 if (!CIFS_CACHE_READ(cinode) || purge_cache) {
4752                         rc = filemap_fdatawait(inode->i_mapping);
4753                         mapping_set_error(inode->i_mapping, rc);
4754                         cifs_zap_mapping(inode);
4755                 }
4756                 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4757                 if (CIFS_CACHE_WRITE(cinode))
4758                         goto oplock_break_ack;
4759         }
4760
4761         rc = cifs_push_locks(cfile);
4762         if (rc)
4763                 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4764
4765 oplock_break_ack:
4766         /*
4767          * releasing stale oplock after recent reconnect of smb session using
4768          * a now incorrect file handle is not a data integrity issue but do
4769          * not bother sending an oplock release if session to server still is
4770          * disconnected since oplock already released by the server
4771          */
4772         if (!cfile->oplock_break_cancelled) {
4773                 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4774                                                              cinode);
4775                 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4776         }
4777         _cifsFileInfo_put(cfile, false /* do not wait for ourself */, false);
4778         cifs_done_oplock_break(cinode);
4779 }
4780
4781 /*
4782  * The presence of cifs_direct_io() in the address space ops vector
4783  * allowes open() O_DIRECT flags which would have failed otherwise.
4784  *
4785  * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4786  * so this method should never be called.
4787  *
4788  * Direct IO is not yet supported in the cached mode.
4789  */
4790 static ssize_t
4791 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4792 {
4793         /*
4794          * FIXME
4795          * Eventually need to support direct IO for non forcedirectio mounts
4796          */
4797         return -EINVAL;
4798 }
4799
4800
4801 const struct address_space_operations cifs_addr_ops = {
4802         .readpage = cifs_readpage,
4803         .readpages = cifs_readpages,
4804         .writepage = cifs_writepage,
4805         .writepages = cifs_writepages,
4806         .write_begin = cifs_write_begin,
4807         .write_end = cifs_write_end,
4808         .set_page_dirty = __set_page_dirty_nobuffers,
4809         .releasepage = cifs_release_page,
4810         .direct_IO = cifs_direct_io,
4811         .invalidatepage = cifs_invalidate_page,
4812         .launder_page = cifs_launder_page,
4813 };
4814
4815 /*
4816  * cifs_readpages requires the server to support a buffer large enough to
4817  * contain the header plus one complete page of data.  Otherwise, we need
4818  * to leave cifs_readpages out of the address space operations.
4819  */
4820 const struct address_space_operations cifs_addr_ops_smallbuf = {
4821         .readpage = cifs_readpage,
4822         .writepage = cifs_writepage,
4823         .writepages = cifs_writepages,
4824         .write_begin = cifs_write_begin,
4825         .write_end = cifs_write_end,
4826         .set_page_dirty = __set_page_dirty_nobuffers,
4827         .releasepage = cifs_release_page,
4828         .invalidatepage = cifs_invalidate_page,
4829         .launder_page = cifs_launder_page,
4830 };