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                 trace_cifs_fsync_err(inode->i_ino, rc);
2598                 return rc;
2599         }
2600
2601         xid = get_xid();
2602
2603         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2604                  file, datasync);
2605
2606         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2607                 rc = cifs_zap_mapping(inode);
2608                 if (rc) {
2609                         cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2610                         rc = 0; /* don't care about it in fsync */
2611                 }
2612         }
2613
2614         tcon = tlink_tcon(smbfile->tlink);
2615         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2616                 server = tcon->ses->server;
2617                 if (server->ops->flush)
2618                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2619                 else
2620                         rc = -ENOSYS;
2621         }
2622
2623         free_xid(xid);
2624         return rc;
2625 }
2626
2627 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2628 {
2629         unsigned int xid;
2630         int rc = 0;
2631         struct cifs_tcon *tcon;
2632         struct TCP_Server_Info *server;
2633         struct cifsFileInfo *smbfile = file->private_data;
2634         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2635
2636         rc = file_write_and_wait_range(file, start, end);
2637         if (rc) {
2638                 trace_cifs_fsync_err(file_inode(file)->i_ino, rc);
2639                 return rc;
2640         }
2641
2642         xid = get_xid();
2643
2644         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2645                  file, datasync);
2646
2647         tcon = tlink_tcon(smbfile->tlink);
2648         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2649                 server = tcon->ses->server;
2650                 if (server->ops->flush)
2651                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2652                 else
2653                         rc = -ENOSYS;
2654         }
2655
2656         free_xid(xid);
2657         return rc;
2658 }
2659
2660 /*
2661  * As file closes, flush all cached write data for this inode checking
2662  * for write behind errors.
2663  */
2664 int cifs_flush(struct file *file, fl_owner_t id)
2665 {
2666         struct inode *inode = file_inode(file);
2667         int rc = 0;
2668
2669         if (file->f_mode & FMODE_WRITE)
2670                 rc = filemap_write_and_wait(inode->i_mapping);
2671
2672         cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2673         if (rc)
2674                 trace_cifs_flush_err(inode->i_ino, rc);
2675         return rc;
2676 }
2677
2678 static int
2679 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2680 {
2681         int rc = 0;
2682         unsigned long i;
2683
2684         for (i = 0; i < num_pages; i++) {
2685                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2686                 if (!pages[i]) {
2687                         /*
2688                          * save number of pages we have already allocated and
2689                          * return with ENOMEM error
2690                          */
2691                         num_pages = i;
2692                         rc = -ENOMEM;
2693                         break;
2694                 }
2695         }
2696
2697         if (rc) {
2698                 for (i = 0; i < num_pages; i++)
2699                         put_page(pages[i]);
2700         }
2701         return rc;
2702 }
2703
2704 static inline
2705 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2706 {
2707         size_t num_pages;
2708         size_t clen;
2709
2710         clen = min_t(const size_t, len, wsize);
2711         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2712
2713         if (cur_len)
2714                 *cur_len = clen;
2715
2716         return num_pages;
2717 }
2718
2719 static void
2720 cifs_uncached_writedata_release(struct kref *refcount)
2721 {
2722         int i;
2723         struct cifs_writedata *wdata = container_of(refcount,
2724                                         struct cifs_writedata, refcount);
2725
2726         kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2727         for (i = 0; i < wdata->nr_pages; i++)
2728                 put_page(wdata->pages[i]);
2729         cifs_writedata_release(refcount);
2730 }
2731
2732 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2733
2734 static void
2735 cifs_uncached_writev_complete(struct work_struct *work)
2736 {
2737         struct cifs_writedata *wdata = container_of(work,
2738                                         struct cifs_writedata, work);
2739         struct inode *inode = d_inode(wdata->cfile->dentry);
2740         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2741
2742         spin_lock(&inode->i_lock);
2743         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2744         if (cifsi->server_eof > inode->i_size)
2745                 i_size_write(inode, cifsi->server_eof);
2746         spin_unlock(&inode->i_lock);
2747
2748         complete(&wdata->done);
2749         collect_uncached_write_data(wdata->ctx);
2750         /* the below call can possibly free the last ref to aio ctx */
2751         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2752 }
2753
2754 static int
2755 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2756                       size_t *len, unsigned long *num_pages)
2757 {
2758         size_t save_len, copied, bytes, cur_len = *len;
2759         unsigned long i, nr_pages = *num_pages;
2760
2761         save_len = cur_len;
2762         for (i = 0; i < nr_pages; i++) {
2763                 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2764                 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2765                 cur_len -= copied;
2766                 /*
2767                  * If we didn't copy as much as we expected, then that
2768                  * may mean we trod into an unmapped area. Stop copying
2769                  * at that point. On the next pass through the big
2770                  * loop, we'll likely end up getting a zero-length
2771                  * write and bailing out of it.
2772                  */
2773                 if (copied < bytes)
2774                         break;
2775         }
2776         cur_len = save_len - cur_len;
2777         *len = cur_len;
2778
2779         /*
2780          * If we have no data to send, then that probably means that
2781          * the copy above failed altogether. That's most likely because
2782          * the address in the iovec was bogus. Return -EFAULT and let
2783          * the caller free anything we allocated and bail out.
2784          */
2785         if (!cur_len)
2786                 return -EFAULT;
2787
2788         /*
2789          * i + 1 now represents the number of pages we actually used in
2790          * the copy phase above.
2791          */
2792         *num_pages = i + 1;
2793         return 0;
2794 }
2795
2796 static int
2797 cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
2798         struct cifs_aio_ctx *ctx)
2799 {
2800         unsigned int wsize;
2801         struct cifs_credits credits;
2802         int rc;
2803         struct TCP_Server_Info *server =
2804                 tlink_tcon(wdata->cfile->tlink)->ses->server;
2805
2806         do {
2807                 if (wdata->cfile->invalidHandle) {
2808                         rc = cifs_reopen_file(wdata->cfile, false);
2809                         if (rc == -EAGAIN)
2810                                 continue;
2811                         else if (rc)
2812                                 break;
2813                 }
2814
2815
2816                 /*
2817                  * Wait for credits to resend this wdata.
2818                  * Note: we are attempting to resend the whole wdata not in
2819                  * segments
2820                  */
2821                 do {
2822                         rc = server->ops->wait_mtu_credits(server, wdata->bytes,
2823                                                 &wsize, &credits);
2824                         if (rc)
2825                                 goto fail;
2826
2827                         if (wsize < wdata->bytes) {
2828                                 add_credits_and_wake_if(server, &credits, 0);
2829                                 msleep(1000);
2830                         }
2831                 } while (wsize < wdata->bytes);
2832                 wdata->credits = credits;
2833
2834                 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2835
2836                 if (!rc) {
2837                         if (wdata->cfile->invalidHandle)
2838                                 rc = -EAGAIN;
2839                         else {
2840 #ifdef CONFIG_CIFS_SMB_DIRECT
2841                                 if (wdata->mr) {
2842                                         wdata->mr->need_invalidate = true;
2843                                         smbd_deregister_mr(wdata->mr);
2844                                         wdata->mr = NULL;
2845                                 }
2846 #endif
2847                                 rc = server->ops->async_writev(wdata,
2848                                         cifs_uncached_writedata_release);
2849                         }
2850                 }
2851
2852                 /* If the write was successfully sent, we are done */
2853                 if (!rc) {
2854                         list_add_tail(&wdata->list, wdata_list);
2855                         return 0;
2856                 }
2857
2858                 /* Roll back credits and retry if needed */
2859                 add_credits_and_wake_if(server, &wdata->credits, 0);
2860         } while (rc == -EAGAIN);
2861
2862 fail:
2863         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2864         return rc;
2865 }
2866
2867 static int
2868 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2869                      struct cifsFileInfo *open_file,
2870                      struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2871                      struct cifs_aio_ctx *ctx)
2872 {
2873         int rc = 0;
2874         size_t cur_len;
2875         unsigned long nr_pages, num_pages, i;
2876         struct cifs_writedata *wdata;
2877         struct iov_iter saved_from = *from;
2878         loff_t saved_offset = offset;
2879         pid_t pid;
2880         struct TCP_Server_Info *server;
2881         struct page **pagevec;
2882         size_t start;
2883         unsigned int xid;
2884
2885         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2886                 pid = open_file->pid;
2887         else
2888                 pid = current->tgid;
2889
2890         server = tlink_tcon(open_file->tlink)->ses->server;
2891         xid = get_xid();
2892
2893         do {
2894                 unsigned int wsize;
2895                 struct cifs_credits credits_on_stack;
2896                 struct cifs_credits *credits = &credits_on_stack;
2897
2898                 if (open_file->invalidHandle) {
2899                         rc = cifs_reopen_file(open_file, false);
2900                         if (rc == -EAGAIN)
2901                                 continue;
2902                         else if (rc)
2903                                 break;
2904                 }
2905
2906                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2907                                                    &wsize, credits);
2908                 if (rc)
2909                         break;
2910
2911                 cur_len = min_t(const size_t, len, wsize);
2912
2913                 if (ctx->direct_io) {
2914                         ssize_t result;
2915
2916                         result = iov_iter_get_pages_alloc(
2917                                 from, &pagevec, cur_len, &start);
2918                         if (result < 0) {
2919                                 cifs_dbg(VFS,
2920                                         "direct_writev couldn't get user pages "
2921                                         "(rc=%zd) iter type %d iov_offset %zd "
2922                                         "count %zd\n",
2923                                         result, iov_iter_type(from),
2924                                         from->iov_offset, from->count);
2925                                 dump_stack();
2926
2927                                 rc = result;
2928                                 add_credits_and_wake_if(server, credits, 0);
2929                                 break;
2930                         }
2931                         cur_len = (size_t)result;
2932                         iov_iter_advance(from, cur_len);
2933
2934                         nr_pages =
2935                                 (cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
2936
2937                         wdata = cifs_writedata_direct_alloc(pagevec,
2938                                              cifs_uncached_writev_complete);
2939                         if (!wdata) {
2940                                 rc = -ENOMEM;
2941                                 add_credits_and_wake_if(server, credits, 0);
2942                                 break;
2943                         }
2944
2945
2946                         wdata->page_offset = start;
2947                         wdata->tailsz =
2948                                 nr_pages > 1 ?
2949                                         cur_len - (PAGE_SIZE - start) -
2950                                         (nr_pages - 2) * PAGE_SIZE :
2951                                         cur_len;
2952                 } else {
2953                         nr_pages = get_numpages(wsize, len, &cur_len);
2954                         wdata = cifs_writedata_alloc(nr_pages,
2955                                              cifs_uncached_writev_complete);
2956                         if (!wdata) {
2957                                 rc = -ENOMEM;
2958                                 add_credits_and_wake_if(server, credits, 0);
2959                                 break;
2960                         }
2961
2962                         rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2963                         if (rc) {
2964                                 kvfree(wdata->pages);
2965                                 kfree(wdata);
2966                                 add_credits_and_wake_if(server, credits, 0);
2967                                 break;
2968                         }
2969
2970                         num_pages = nr_pages;
2971                         rc = wdata_fill_from_iovec(
2972                                 wdata, from, &cur_len, &num_pages);
2973                         if (rc) {
2974                                 for (i = 0; i < nr_pages; i++)
2975                                         put_page(wdata->pages[i]);
2976                                 kvfree(wdata->pages);
2977                                 kfree(wdata);
2978                                 add_credits_and_wake_if(server, credits, 0);
2979                                 break;
2980                         }
2981
2982                         /*
2983                          * Bring nr_pages down to the number of pages we
2984                          * actually used, and free any pages that we didn't use.
2985                          */
2986                         for ( ; nr_pages > num_pages; nr_pages--)
2987                                 put_page(wdata->pages[nr_pages - 1]);
2988
2989                         wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2990                 }
2991
2992                 wdata->sync_mode = WB_SYNC_ALL;
2993                 wdata->nr_pages = nr_pages;
2994                 wdata->offset = (__u64)offset;
2995                 wdata->cfile = cifsFileInfo_get(open_file);
2996                 wdata->pid = pid;
2997                 wdata->bytes = cur_len;
2998                 wdata->pagesz = PAGE_SIZE;
2999                 wdata->credits = credits_on_stack;
3000                 wdata->ctx = ctx;
3001                 kref_get(&ctx->refcount);
3002
3003                 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3004
3005                 if (!rc) {
3006                         if (wdata->cfile->invalidHandle)
3007                                 rc = -EAGAIN;
3008                         else
3009                                 rc = server->ops->async_writev(wdata,
3010                                         cifs_uncached_writedata_release);
3011                 }
3012
3013                 if (rc) {
3014                         add_credits_and_wake_if(server, &wdata->credits, 0);
3015                         kref_put(&wdata->refcount,
3016                                  cifs_uncached_writedata_release);
3017                         if (rc == -EAGAIN) {
3018                                 *from = saved_from;
3019                                 iov_iter_advance(from, offset - saved_offset);
3020                                 continue;
3021                         }
3022                         break;
3023                 }
3024
3025                 list_add_tail(&wdata->list, wdata_list);
3026                 offset += cur_len;
3027                 len -= cur_len;
3028         } while (len > 0);
3029
3030         free_xid(xid);
3031         return rc;
3032 }
3033
3034 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
3035 {
3036         struct cifs_writedata *wdata, *tmp;
3037         struct cifs_tcon *tcon;
3038         struct cifs_sb_info *cifs_sb;
3039         struct dentry *dentry = ctx->cfile->dentry;
3040         int rc;
3041
3042         tcon = tlink_tcon(ctx->cfile->tlink);
3043         cifs_sb = CIFS_SB(dentry->d_sb);
3044
3045         mutex_lock(&ctx->aio_mutex);
3046
3047         if (list_empty(&ctx->list)) {
3048                 mutex_unlock(&ctx->aio_mutex);
3049                 return;
3050         }
3051
3052         rc = ctx->rc;
3053         /*
3054          * Wait for and collect replies for any successful sends in order of
3055          * increasing offset. Once an error is hit, then return without waiting
3056          * for any more replies.
3057          */
3058 restart_loop:
3059         list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
3060                 if (!rc) {
3061                         if (!try_wait_for_completion(&wdata->done)) {
3062                                 mutex_unlock(&ctx->aio_mutex);
3063                                 return;
3064                         }
3065
3066                         if (wdata->result)
3067                                 rc = wdata->result;
3068                         else
3069                                 ctx->total_len += wdata->bytes;
3070
3071                         /* resend call if it's a retryable error */
3072                         if (rc == -EAGAIN) {
3073                                 struct list_head tmp_list;
3074                                 struct iov_iter tmp_from = ctx->iter;
3075
3076                                 INIT_LIST_HEAD(&tmp_list);
3077                                 list_del_init(&wdata->list);
3078
3079                                 if (ctx->direct_io)
3080                                         rc = cifs_resend_wdata(
3081                                                 wdata, &tmp_list, ctx);
3082                                 else {
3083                                         iov_iter_advance(&tmp_from,
3084                                                  wdata->offset - ctx->pos);
3085
3086                                         rc = cifs_write_from_iter(wdata->offset,
3087                                                 wdata->bytes, &tmp_from,
3088                                                 ctx->cfile, cifs_sb, &tmp_list,
3089                                                 ctx);
3090
3091                                         kref_put(&wdata->refcount,
3092                                                 cifs_uncached_writedata_release);
3093                                 }
3094
3095                                 list_splice(&tmp_list, &ctx->list);
3096                                 goto restart_loop;
3097                         }
3098                 }
3099                 list_del_init(&wdata->list);
3100                 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3101         }
3102
3103         cifs_stats_bytes_written(tcon, ctx->total_len);
3104         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
3105
3106         ctx->rc = (rc == 0) ? ctx->total_len : rc;
3107
3108         mutex_unlock(&ctx->aio_mutex);
3109
3110         if (ctx->iocb && ctx->iocb->ki_complete)
3111                 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3112         else
3113                 complete(&ctx->done);
3114 }
3115
3116 static ssize_t __cifs_writev(
3117         struct kiocb *iocb, struct iov_iter *from, bool direct)
3118 {
3119         struct file *file = iocb->ki_filp;
3120         ssize_t total_written = 0;
3121         struct cifsFileInfo *cfile;
3122         struct cifs_tcon *tcon;
3123         struct cifs_sb_info *cifs_sb;
3124         struct cifs_aio_ctx *ctx;
3125         struct iov_iter saved_from = *from;
3126         size_t len = iov_iter_count(from);
3127         int rc;
3128
3129         /*
3130          * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
3131          * In this case, fall back to non-direct write function.
3132          * this could be improved by getting pages directly in ITER_KVEC
3133          */
3134         if (direct && iov_iter_is_kvec(from)) {
3135                 cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
3136                 direct = false;
3137         }
3138
3139         rc = generic_write_checks(iocb, from);
3140         if (rc <= 0)
3141                 return rc;
3142
3143         cifs_sb = CIFS_FILE_SB(file);
3144         cfile = file->private_data;
3145         tcon = tlink_tcon(cfile->tlink);
3146
3147         if (!tcon->ses->server->ops->async_writev)
3148                 return -ENOSYS;
3149
3150         ctx = cifs_aio_ctx_alloc();
3151         if (!ctx)
3152                 return -ENOMEM;
3153
3154         ctx->cfile = cifsFileInfo_get(cfile);
3155
3156         if (!is_sync_kiocb(iocb))
3157                 ctx->iocb = iocb;
3158
3159         ctx->pos = iocb->ki_pos;
3160
3161         if (direct) {
3162                 ctx->direct_io = true;
3163                 ctx->iter = *from;
3164                 ctx->len = len;
3165         } else {
3166                 rc = setup_aio_ctx_iter(ctx, from, WRITE);
3167                 if (rc) {
3168                         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3169                         return rc;
3170                 }
3171         }
3172
3173         /* grab a lock here due to read response handlers can access ctx */
3174         mutex_lock(&ctx->aio_mutex);
3175
3176         rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3177                                   cfile, cifs_sb, &ctx->list, ctx);
3178
3179         /*
3180          * If at least one write was successfully sent, then discard any rc
3181          * value from the later writes. If the other write succeeds, then
3182          * we'll end up returning whatever was written. If it fails, then
3183          * we'll get a new rc value from that.
3184          */
3185         if (!list_empty(&ctx->list))
3186                 rc = 0;
3187
3188         mutex_unlock(&ctx->aio_mutex);
3189
3190         if (rc) {
3191                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3192                 return rc;
3193         }
3194
3195         if (!is_sync_kiocb(iocb)) {
3196                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3197                 return -EIOCBQUEUED;
3198         }
3199
3200         rc = wait_for_completion_killable(&ctx->done);
3201         if (rc) {
3202                 mutex_lock(&ctx->aio_mutex);
3203                 ctx->rc = rc = -EINTR;
3204                 total_written = ctx->total_len;
3205                 mutex_unlock(&ctx->aio_mutex);
3206         } else {
3207                 rc = ctx->rc;
3208                 total_written = ctx->total_len;
3209         }
3210
3211         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3212
3213         if (unlikely(!total_written))
3214                 return rc;
3215
3216         iocb->ki_pos += total_written;
3217         return total_written;
3218 }
3219
3220 ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3221 {
3222         return __cifs_writev(iocb, from, true);
3223 }
3224
3225 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3226 {
3227         return __cifs_writev(iocb, from, false);
3228 }
3229
3230 static ssize_t
3231 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3232 {
3233         struct file *file = iocb->ki_filp;
3234         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3235         struct inode *inode = file->f_mapping->host;
3236         struct cifsInodeInfo *cinode = CIFS_I(inode);
3237         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3238         ssize_t rc;
3239
3240         inode_lock(inode);
3241         /*
3242          * We need to hold the sem to be sure nobody modifies lock list
3243          * with a brlock that prevents writing.
3244          */
3245         down_read(&cinode->lock_sem);
3246
3247         rc = generic_write_checks(iocb, from);
3248         if (rc <= 0)
3249                 goto out;
3250
3251         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3252                                      server->vals->exclusive_lock_type, 0,
3253                                      NULL, CIFS_WRITE_OP))
3254                 rc = __generic_file_write_iter(iocb, from);
3255         else
3256                 rc = -EACCES;
3257 out:
3258         up_read(&cinode->lock_sem);
3259         inode_unlock(inode);
3260
3261         if (rc > 0)
3262                 rc = generic_write_sync(iocb, rc);
3263         return rc;
3264 }
3265
3266 ssize_t
3267 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3268 {
3269         struct inode *inode = file_inode(iocb->ki_filp);
3270         struct cifsInodeInfo *cinode = CIFS_I(inode);
3271         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3272         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3273                                                 iocb->ki_filp->private_data;
3274         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3275         ssize_t written;
3276
3277         written = cifs_get_writer(cinode);
3278         if (written)
3279                 return written;
3280
3281         if (CIFS_CACHE_WRITE(cinode)) {
3282                 if (cap_unix(tcon->ses) &&
3283                 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3284                   && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3285                         written = generic_file_write_iter(iocb, from);
3286                         goto out;
3287                 }
3288                 written = cifs_writev(iocb, from);
3289                 goto out;
3290         }
3291         /*
3292          * For non-oplocked files in strict cache mode we need to write the data
3293          * to the server exactly from the pos to pos+len-1 rather than flush all
3294          * affected pages because it may cause a error with mandatory locks on
3295          * these pages but not on the region from pos to ppos+len-1.
3296          */
3297         written = cifs_user_writev(iocb, from);
3298         if (CIFS_CACHE_READ(cinode)) {
3299                 /*
3300                  * We have read level caching and we have just sent a write
3301                  * request to the server thus making data in the cache stale.
3302                  * Zap the cache and set oplock/lease level to NONE to avoid
3303                  * reading stale data from the cache. All subsequent read
3304                  * operations will read new data from the server.
3305                  */
3306                 cifs_zap_mapping(inode);
3307                 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3308                          inode);
3309                 cinode->oplock = 0;
3310         }
3311 out:
3312         cifs_put_writer(cinode);
3313         return written;
3314 }
3315
3316 static struct cifs_readdata *
3317 cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3318 {
3319         struct cifs_readdata *rdata;
3320
3321         rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3322         if (rdata != NULL) {
3323                 rdata->pages = pages;
3324                 kref_init(&rdata->refcount);
3325                 INIT_LIST_HEAD(&rdata->list);
3326                 init_completion(&rdata->done);
3327                 INIT_WORK(&rdata->work, complete);
3328         }
3329
3330         return rdata;
3331 }
3332
3333 static struct cifs_readdata *
3334 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3335 {
3336         struct page **pages =
3337                 kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3338         struct cifs_readdata *ret = NULL;
3339
3340         if (pages) {
3341                 ret = cifs_readdata_direct_alloc(pages, complete);
3342                 if (!ret)
3343                         kfree(pages);
3344         }
3345
3346         return ret;
3347 }
3348
3349 void
3350 cifs_readdata_release(struct kref *refcount)
3351 {
3352         struct cifs_readdata *rdata = container_of(refcount,
3353                                         struct cifs_readdata, refcount);
3354 #ifdef CONFIG_CIFS_SMB_DIRECT
3355         if (rdata->mr) {
3356                 smbd_deregister_mr(rdata->mr);
3357                 rdata->mr = NULL;
3358         }
3359 #endif
3360         if (rdata->cfile)
3361                 cifsFileInfo_put(rdata->cfile);
3362
3363         kvfree(rdata->pages);
3364         kfree(rdata);
3365 }
3366
3367 static int
3368 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3369 {
3370         int rc = 0;
3371         struct page *page;
3372         unsigned int i;
3373
3374         for (i = 0; i < nr_pages; i++) {
3375                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3376                 if (!page) {
3377                         rc = -ENOMEM;
3378                         break;
3379                 }
3380                 rdata->pages[i] = page;
3381         }
3382
3383         if (rc) {
3384                 unsigned int nr_page_failed = i;
3385
3386                 for (i = 0; i < nr_page_failed; i++) {
3387                         put_page(rdata->pages[i]);
3388                         rdata->pages[i] = NULL;
3389                 }
3390         }
3391         return rc;
3392 }
3393
3394 static void
3395 cifs_uncached_readdata_release(struct kref *refcount)
3396 {
3397         struct cifs_readdata *rdata = container_of(refcount,
3398                                         struct cifs_readdata, refcount);
3399         unsigned int i;
3400
3401         kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3402         for (i = 0; i < rdata->nr_pages; i++) {
3403                 put_page(rdata->pages[i]);
3404         }
3405         cifs_readdata_release(refcount);
3406 }
3407
3408 /**
3409  * cifs_readdata_to_iov - copy data from pages in response to an iovec
3410  * @rdata:      the readdata response with list of pages holding data
3411  * @iter:       destination for our data
3412  *
3413  * This function copies data from a list of pages in a readdata response into
3414  * an array of iovecs. It will first calculate where the data should go
3415  * based on the info in the readdata and then copy the data into that spot.
3416  */
3417 static int
3418 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3419 {
3420         size_t remaining = rdata->got_bytes;
3421         unsigned int i;
3422
3423         for (i = 0; i < rdata->nr_pages; i++) {
3424                 struct page *page = rdata->pages[i];
3425                 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3426                 size_t written;
3427
3428                 if (unlikely(iov_iter_is_pipe(iter))) {
3429                         void *addr = kmap_atomic(page);
3430
3431                         written = copy_to_iter(addr, copy, iter);
3432                         kunmap_atomic(addr);
3433                 } else
3434                         written = copy_page_to_iter(page, 0, copy, iter);
3435                 remaining -= written;
3436                 if (written < copy && iov_iter_count(iter) > 0)
3437                         break;
3438         }
3439         return remaining ? -EFAULT : 0;
3440 }
3441
3442 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3443
3444 static void
3445 cifs_uncached_readv_complete(struct work_struct *work)
3446 {
3447         struct cifs_readdata *rdata = container_of(work,
3448                                                 struct cifs_readdata, work);
3449
3450         complete(&rdata->done);
3451         collect_uncached_read_data(rdata->ctx);
3452         /* the below call can possibly free the last ref to aio ctx */
3453         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3454 }
3455
3456 static int
3457 uncached_fill_pages(struct TCP_Server_Info *server,
3458                     struct cifs_readdata *rdata, struct iov_iter *iter,
3459                     unsigned int len)
3460 {
3461         int result = 0;
3462         unsigned int i;
3463         unsigned int nr_pages = rdata->nr_pages;
3464         unsigned int page_offset = rdata->page_offset;
3465
3466         rdata->got_bytes = 0;
3467         rdata->tailsz = PAGE_SIZE;
3468         for (i = 0; i < nr_pages; i++) {
3469                 struct page *page = rdata->pages[i];
3470                 size_t n;
3471                 unsigned int segment_size = rdata->pagesz;
3472
3473                 if (i == 0)
3474                         segment_size -= page_offset;
3475                 else
3476                         page_offset = 0;
3477
3478
3479                 if (len <= 0) {
3480                         /* no need to hold page hostage */
3481                         rdata->pages[i] = NULL;
3482                         rdata->nr_pages--;
3483                         put_page(page);
3484                         continue;
3485                 }
3486
3487                 n = len;
3488                 if (len >= segment_size)
3489                         /* enough data to fill the page */
3490                         n = segment_size;
3491                 else
3492                         rdata->tailsz = len;
3493                 len -= n;
3494
3495                 if (iter)
3496                         result = copy_page_from_iter(
3497                                         page, page_offset, n, iter);
3498 #ifdef CONFIG_CIFS_SMB_DIRECT
3499                 else if (rdata->mr)
3500                         result = n;
3501 #endif
3502                 else
3503                         result = cifs_read_page_from_socket(
3504                                         server, page, page_offset, n);
3505                 if (result < 0)
3506                         break;
3507
3508                 rdata->got_bytes += result;
3509         }
3510
3511         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3512                                                 rdata->got_bytes : result;
3513 }
3514
3515 static int
3516 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3517                               struct cifs_readdata *rdata, unsigned int len)
3518 {
3519         return uncached_fill_pages(server, rdata, NULL, len);
3520 }
3521
3522 static int
3523 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3524                               struct cifs_readdata *rdata,
3525                               struct iov_iter *iter)
3526 {
3527         return uncached_fill_pages(server, rdata, iter, iter->count);
3528 }
3529
3530 static int cifs_resend_rdata(struct cifs_readdata *rdata,
3531                         struct list_head *rdata_list,
3532                         struct cifs_aio_ctx *ctx)
3533 {
3534         unsigned int rsize;
3535         struct cifs_credits credits;
3536         int rc;
3537         struct TCP_Server_Info *server =
3538                 tlink_tcon(rdata->cfile->tlink)->ses->server;
3539
3540         do {
3541                 if (rdata->cfile->invalidHandle) {
3542                         rc = cifs_reopen_file(rdata->cfile, true);
3543                         if (rc == -EAGAIN)
3544                                 continue;
3545                         else if (rc)
3546                                 break;
3547                 }
3548
3549                 /*
3550                  * Wait for credits to resend this rdata.
3551                  * Note: we are attempting to resend the whole rdata not in
3552                  * segments
3553                  */
3554                 do {
3555                         rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3556                                                 &rsize, &credits);
3557
3558                         if (rc)
3559                                 goto fail;
3560
3561                         if (rsize < rdata->bytes) {
3562                                 add_credits_and_wake_if(server, &credits, 0);
3563                                 msleep(1000);
3564                         }
3565                 } while (rsize < rdata->bytes);
3566                 rdata->credits = credits;
3567
3568                 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3569                 if (!rc) {
3570                         if (rdata->cfile->invalidHandle)
3571                                 rc = -EAGAIN;
3572                         else {
3573 #ifdef CONFIG_CIFS_SMB_DIRECT
3574                                 if (rdata->mr) {
3575                                         rdata->mr->need_invalidate = true;
3576                                         smbd_deregister_mr(rdata->mr);
3577                                         rdata->mr = NULL;
3578                                 }
3579 #endif
3580                                 rc = server->ops->async_readv(rdata);
3581                         }
3582                 }
3583
3584                 /* If the read was successfully sent, we are done */
3585                 if (!rc) {
3586                         /* Add to aio pending list */
3587                         list_add_tail(&rdata->list, rdata_list);
3588                         return 0;
3589                 }
3590
3591                 /* Roll back credits and retry if needed */
3592                 add_credits_and_wake_if(server, &rdata->credits, 0);
3593         } while (rc == -EAGAIN);
3594
3595 fail:
3596         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3597         return rc;
3598 }
3599
3600 static int
3601 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3602                      struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3603                      struct cifs_aio_ctx *ctx)
3604 {
3605         struct cifs_readdata *rdata;
3606         unsigned int npages, rsize;
3607         struct cifs_credits credits_on_stack;
3608         struct cifs_credits *credits = &credits_on_stack;
3609         size_t cur_len;
3610         int rc;
3611         pid_t pid;
3612         struct TCP_Server_Info *server;
3613         struct page **pagevec;
3614         size_t start;
3615         struct iov_iter direct_iov = ctx->iter;
3616
3617         server = tlink_tcon(open_file->tlink)->ses->server;
3618
3619         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3620                 pid = open_file->pid;
3621         else
3622                 pid = current->tgid;
3623
3624         if (ctx->direct_io)
3625                 iov_iter_advance(&direct_iov, offset - ctx->pos);
3626
3627         do {
3628                 if (open_file->invalidHandle) {
3629                         rc = cifs_reopen_file(open_file, true);
3630                         if (rc == -EAGAIN)
3631                                 continue;
3632                         else if (rc)
3633                                 break;
3634                 }
3635
3636                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3637                                                    &rsize, credits);
3638                 if (rc)
3639                         break;
3640
3641                 cur_len = min_t(const size_t, len, rsize);
3642
3643                 if (ctx->direct_io) {
3644                         ssize_t result;
3645
3646                         result = iov_iter_get_pages_alloc(
3647                                         &direct_iov, &pagevec,
3648                                         cur_len, &start);
3649                         if (result < 0) {
3650                                 cifs_dbg(VFS,
3651                                         "couldn't get user pages (rc=%zd)"
3652                                         " iter type %d"
3653                                         " iov_offset %zd count %zd\n",
3654                                         result, iov_iter_type(&direct_iov),
3655                                         direct_iov.iov_offset,
3656                                         direct_iov.count);
3657                                 dump_stack();
3658
3659                                 rc = result;
3660                                 add_credits_and_wake_if(server, credits, 0);
3661                                 break;
3662                         }
3663                         cur_len = (size_t)result;
3664                         iov_iter_advance(&direct_iov, cur_len);
3665
3666                         rdata = cifs_readdata_direct_alloc(
3667                                         pagevec, cifs_uncached_readv_complete);
3668                         if (!rdata) {
3669                                 add_credits_and_wake_if(server, credits, 0);
3670                                 rc = -ENOMEM;
3671                                 break;
3672                         }
3673
3674                         npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
3675                         rdata->page_offset = start;
3676                         rdata->tailsz = npages > 1 ?
3677                                 cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
3678                                 cur_len;
3679
3680                 } else {
3681
3682                         npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3683                         /* allocate a readdata struct */
3684                         rdata = cifs_readdata_alloc(npages,
3685                                             cifs_uncached_readv_complete);
3686                         if (!rdata) {
3687                                 add_credits_and_wake_if(server, credits, 0);
3688                                 rc = -ENOMEM;
3689                                 break;
3690                         }
3691
3692                         rc = cifs_read_allocate_pages(rdata, npages);
3693                         if (rc) {
3694                                 kvfree(rdata->pages);
3695                                 kfree(rdata);
3696                                 add_credits_and_wake_if(server, credits, 0);
3697                                 break;
3698                         }
3699
3700                         rdata->tailsz = PAGE_SIZE;
3701                 }
3702
3703                 rdata->cfile = cifsFileInfo_get(open_file);
3704                 rdata->nr_pages = npages;
3705                 rdata->offset = offset;
3706                 rdata->bytes = cur_len;
3707                 rdata->pid = pid;
3708                 rdata->pagesz = PAGE_SIZE;
3709                 rdata->read_into_pages = cifs_uncached_read_into_pages;
3710                 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3711                 rdata->credits = credits_on_stack;
3712                 rdata->ctx = ctx;
3713                 kref_get(&ctx->refcount);
3714
3715                 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3716
3717                 if (!rc) {
3718                         if (rdata->cfile->invalidHandle)
3719                                 rc = -EAGAIN;
3720                         else
3721                                 rc = server->ops->async_readv(rdata);
3722                 }
3723
3724                 if (rc) {
3725                         add_credits_and_wake_if(server, &rdata->credits, 0);
3726                         kref_put(&rdata->refcount,
3727                                 cifs_uncached_readdata_release);
3728                         if (rc == -EAGAIN) {
3729                                 iov_iter_revert(&direct_iov, cur_len);
3730                                 continue;
3731                         }
3732                         break;
3733                 }
3734
3735                 list_add_tail(&rdata->list, rdata_list);
3736                 offset += cur_len;
3737                 len -= cur_len;
3738         } while (len > 0);
3739
3740         return rc;
3741 }
3742
3743 static void
3744 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3745 {
3746         struct cifs_readdata *rdata, *tmp;
3747         struct iov_iter *to = &ctx->iter;
3748         struct cifs_sb_info *cifs_sb;
3749         int rc;
3750
3751         cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3752
3753         mutex_lock(&ctx->aio_mutex);
3754
3755         if (list_empty(&ctx->list)) {
3756                 mutex_unlock(&ctx->aio_mutex);
3757                 return;
3758         }
3759
3760         rc = ctx->rc;
3761         /* the loop below should proceed in the order of increasing offsets */
3762 again:
3763         list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3764                 if (!rc) {
3765                         if (!try_wait_for_completion(&rdata->done)) {
3766                                 mutex_unlock(&ctx->aio_mutex);
3767                                 return;
3768                         }
3769
3770                         if (rdata->result == -EAGAIN) {
3771                                 /* resend call if it's a retryable error */
3772                                 struct list_head tmp_list;
3773                                 unsigned int got_bytes = rdata->got_bytes;
3774
3775                                 list_del_init(&rdata->list);
3776                                 INIT_LIST_HEAD(&tmp_list);
3777
3778                                 /*
3779                                  * Got a part of data and then reconnect has
3780                                  * happened -- fill the buffer and continue
3781                                  * reading.
3782                                  */
3783                                 if (got_bytes && got_bytes < rdata->bytes) {
3784                                         rc = 0;
3785                                         if (!ctx->direct_io)
3786                                                 rc = cifs_readdata_to_iov(rdata, to);
3787                                         if (rc) {
3788                                                 kref_put(&rdata->refcount,
3789                                                         cifs_uncached_readdata_release);
3790                                                 continue;
3791                                         }
3792                                 }
3793
3794                                 if (ctx->direct_io) {
3795                                         /*
3796                                          * Re-use rdata as this is a
3797                                          * direct I/O
3798                                          */
3799                                         rc = cifs_resend_rdata(
3800                                                 rdata,
3801                                                 &tmp_list, ctx);
3802                                 } else {
3803                                         rc = cifs_send_async_read(
3804                                                 rdata->offset + got_bytes,
3805                                                 rdata->bytes - got_bytes,
3806                                                 rdata->cfile, cifs_sb,
3807                                                 &tmp_list, ctx);
3808
3809                                         kref_put(&rdata->refcount,
3810                                                 cifs_uncached_readdata_release);
3811                                 }
3812
3813                                 list_splice(&tmp_list, &ctx->list);
3814
3815                                 goto again;
3816                         } else if (rdata->result)
3817                                 rc = rdata->result;
3818                         else if (!ctx->direct_io)
3819                                 rc = cifs_readdata_to_iov(rdata, to);
3820
3821                         /* if there was a short read -- discard anything left */
3822                         if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3823                                 rc = -ENODATA;
3824
3825                         ctx->total_len += rdata->got_bytes;
3826                 }
3827                 list_del_init(&rdata->list);
3828                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3829         }
3830
3831         if (!ctx->direct_io)
3832                 ctx->total_len = ctx->len - iov_iter_count(to);
3833
3834         /* mask nodata case */
3835         if (rc == -ENODATA)
3836                 rc = 0;
3837
3838         ctx->rc = (rc == 0) ? ctx->total_len : rc;
3839
3840         mutex_unlock(&ctx->aio_mutex);
3841
3842         if (ctx->iocb && ctx->iocb->ki_complete)
3843                 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3844         else
3845                 complete(&ctx->done);
3846 }
3847
3848 static ssize_t __cifs_readv(
3849         struct kiocb *iocb, struct iov_iter *to, bool direct)
3850 {
3851         size_t len;
3852         struct file *file = iocb->ki_filp;
3853         struct cifs_sb_info *cifs_sb;
3854         struct cifsFileInfo *cfile;
3855         struct cifs_tcon *tcon;
3856         ssize_t rc, total_read = 0;
3857         loff_t offset = iocb->ki_pos;
3858         struct cifs_aio_ctx *ctx;
3859
3860         /*
3861          * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3862          * fall back to data copy read path
3863          * this could be improved by getting pages directly in ITER_KVEC
3864          */
3865         if (direct && iov_iter_is_kvec(to)) {
3866                 cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
3867                 direct = false;
3868         }
3869
3870         len = iov_iter_count(to);
3871         if (!len)
3872                 return 0;
3873
3874         cifs_sb = CIFS_FILE_SB(file);
3875         cfile = file->private_data;
3876         tcon = tlink_tcon(cfile->tlink);
3877
3878         if (!tcon->ses->server->ops->async_readv)
3879                 return -ENOSYS;
3880
3881         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3882                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3883
3884         ctx = cifs_aio_ctx_alloc();
3885         if (!ctx)
3886                 return -ENOMEM;
3887
3888         ctx->cfile = cifsFileInfo_get(cfile);
3889
3890         if (!is_sync_kiocb(iocb))
3891                 ctx->iocb = iocb;
3892
3893         if (iter_is_iovec(to))
3894                 ctx->should_dirty = true;
3895
3896         if (direct) {
3897                 ctx->pos = offset;
3898                 ctx->direct_io = true;
3899                 ctx->iter = *to;
3900                 ctx->len = len;
3901         } else {
3902                 rc = setup_aio_ctx_iter(ctx, to, READ);
3903                 if (rc) {
3904                         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3905                         return rc;
3906                 }
3907                 len = ctx->len;
3908         }
3909
3910         /* grab a lock here due to read response handlers can access ctx */
3911         mutex_lock(&ctx->aio_mutex);
3912
3913         rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3914
3915         /* if at least one read request send succeeded, then reset rc */
3916         if (!list_empty(&ctx->list))
3917                 rc = 0;
3918
3919         mutex_unlock(&ctx->aio_mutex);
3920
3921         if (rc) {
3922                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3923                 return rc;
3924         }
3925
3926         if (!is_sync_kiocb(iocb)) {
3927                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3928                 return -EIOCBQUEUED;
3929         }
3930
3931         rc = wait_for_completion_killable(&ctx->done);
3932         if (rc) {
3933                 mutex_lock(&ctx->aio_mutex);
3934                 ctx->rc = rc = -EINTR;
3935                 total_read = ctx->total_len;
3936                 mutex_unlock(&ctx->aio_mutex);
3937         } else {
3938                 rc = ctx->rc;
3939                 total_read = ctx->total_len;
3940         }
3941
3942         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3943
3944         if (total_read) {
3945                 iocb->ki_pos += total_read;
3946                 return total_read;
3947         }
3948         return rc;
3949 }
3950
3951 ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
3952 {
3953         return __cifs_readv(iocb, to, true);
3954 }
3955
3956 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3957 {
3958         return __cifs_readv(iocb, to, false);
3959 }
3960
3961 ssize_t
3962 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3963 {
3964         struct inode *inode = file_inode(iocb->ki_filp);
3965         struct cifsInodeInfo *cinode = CIFS_I(inode);
3966         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3967         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3968                                                 iocb->ki_filp->private_data;
3969         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3970         int rc = -EACCES;
3971
3972         /*
3973          * In strict cache mode we need to read from the server all the time
3974          * if we don't have level II oplock because the server can delay mtime
3975          * change - so we can't make a decision about inode invalidating.
3976          * And we can also fail with pagereading if there are mandatory locks
3977          * on pages affected by this read but not on the region from pos to
3978          * pos+len-1.
3979          */
3980         if (!CIFS_CACHE_READ(cinode))
3981                 return cifs_user_readv(iocb, to);
3982
3983         if (cap_unix(tcon->ses) &&
3984             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3985             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3986                 return generic_file_read_iter(iocb, to);
3987
3988         /*
3989          * We need to hold the sem to be sure nobody modifies lock list
3990          * with a brlock that prevents reading.
3991          */
3992         down_read(&cinode->lock_sem);
3993         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3994                                      tcon->ses->server->vals->shared_lock_type,
3995                                      0, NULL, CIFS_READ_OP))
3996                 rc = generic_file_read_iter(iocb, to);
3997         up_read(&cinode->lock_sem);
3998         return rc;
3999 }
4000
4001 static ssize_t
4002 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
4003 {
4004         int rc = -EACCES;
4005         unsigned int bytes_read = 0;
4006         unsigned int total_read;
4007         unsigned int current_read_size;
4008         unsigned int rsize;
4009         struct cifs_sb_info *cifs_sb;
4010         struct cifs_tcon *tcon;
4011         struct TCP_Server_Info *server;
4012         unsigned int xid;
4013         char *cur_offset;
4014         struct cifsFileInfo *open_file;
4015         struct cifs_io_parms io_parms;
4016         int buf_type = CIFS_NO_BUFFER;
4017         __u32 pid;
4018
4019         xid = get_xid();
4020         cifs_sb = CIFS_FILE_SB(file);
4021
4022         /* FIXME: set up handlers for larger reads and/or convert to async */
4023         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
4024
4025         if (file->private_data == NULL) {
4026                 rc = -EBADF;
4027                 free_xid(xid);
4028                 return rc;
4029         }
4030         open_file = file->private_data;
4031         tcon = tlink_tcon(open_file->tlink);
4032         server = tcon->ses->server;
4033
4034         if (!server->ops->sync_read) {
4035                 free_xid(xid);
4036                 return -ENOSYS;
4037         }
4038
4039         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4040                 pid = open_file->pid;
4041         else
4042                 pid = current->tgid;
4043
4044         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
4045                 cifs_dbg(FYI, "attempting read on write only file instance\n");
4046
4047         for (total_read = 0, cur_offset = read_data; read_size > total_read;
4048              total_read += bytes_read, cur_offset += bytes_read) {
4049                 do {
4050                         current_read_size = min_t(uint, read_size - total_read,
4051                                                   rsize);
4052                         /*
4053                          * For windows me and 9x we do not want to request more
4054                          * than it negotiated since it will refuse the read
4055                          * then.
4056                          */
4057                         if ((tcon->ses) && !(tcon->ses->capabilities &
4058                                 tcon->ses->server->vals->cap_large_files)) {
4059                                 current_read_size = min_t(uint,
4060                                         current_read_size, CIFSMaxBufSize);
4061                         }
4062                         if (open_file->invalidHandle) {
4063                                 rc = cifs_reopen_file(open_file, true);
4064                                 if (rc != 0)
4065                                         break;
4066                         }
4067                         io_parms.pid = pid;
4068                         io_parms.tcon = tcon;
4069                         io_parms.offset = *offset;
4070                         io_parms.length = current_read_size;
4071                         rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
4072                                                     &bytes_read, &cur_offset,
4073                                                     &buf_type);
4074                 } while (rc == -EAGAIN);
4075
4076                 if (rc || (bytes_read == 0)) {
4077                         if (total_read) {
4078                                 break;
4079                         } else {
4080                                 free_xid(xid);
4081                                 return rc;
4082                         }
4083                 } else {
4084                         cifs_stats_bytes_read(tcon, total_read);
4085                         *offset += bytes_read;
4086                 }
4087         }
4088         free_xid(xid);
4089         return total_read;
4090 }
4091
4092 /*
4093  * If the page is mmap'ed into a process' page tables, then we need to make
4094  * sure that it doesn't change while being written back.
4095  */
4096 static vm_fault_t
4097 cifs_page_mkwrite(struct vm_fault *vmf)
4098 {
4099         struct page *page = vmf->page;
4100
4101         lock_page(page);
4102         return VM_FAULT_LOCKED;
4103 }
4104
4105 static const struct vm_operations_struct cifs_file_vm_ops = {
4106         .fault = filemap_fault,
4107         .map_pages = filemap_map_pages,
4108         .page_mkwrite = cifs_page_mkwrite,
4109 };
4110
4111 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
4112 {
4113         int xid, rc = 0;
4114         struct inode *inode = file_inode(file);
4115
4116         xid = get_xid();
4117
4118         if (!CIFS_CACHE_READ(CIFS_I(inode)))
4119                 rc = cifs_zap_mapping(inode);
4120         if (!rc)
4121                 rc = generic_file_mmap(file, vma);
4122         if (!rc)
4123                 vma->vm_ops = &cifs_file_vm_ops;
4124
4125         free_xid(xid);
4126         return rc;
4127 }
4128
4129 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
4130 {
4131         int rc, xid;
4132
4133         xid = get_xid();
4134
4135         rc = cifs_revalidate_file(file);
4136         if (rc)
4137                 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
4138                          rc);
4139         if (!rc)
4140                 rc = generic_file_mmap(file, vma);
4141         if (!rc)
4142                 vma->vm_ops = &cifs_file_vm_ops;
4143
4144         free_xid(xid);
4145         return rc;
4146 }
4147
4148 static void
4149 cifs_readv_complete(struct work_struct *work)
4150 {
4151         unsigned int i, got_bytes;
4152         struct cifs_readdata *rdata = container_of(work,
4153                                                 struct cifs_readdata, work);
4154
4155         got_bytes = rdata->got_bytes;
4156         for (i = 0; i < rdata->nr_pages; i++) {
4157                 struct page *page = rdata->pages[i];
4158
4159                 lru_cache_add_file(page);
4160
4161                 if (rdata->result == 0 ||
4162                     (rdata->result == -EAGAIN && got_bytes)) {
4163                         flush_dcache_page(page);
4164                         SetPageUptodate(page);
4165                 }
4166
4167                 unlock_page(page);
4168
4169                 if (rdata->result == 0 ||
4170                     (rdata->result == -EAGAIN && got_bytes))
4171                         cifs_readpage_to_fscache(rdata->mapping->host, page);
4172
4173                 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4174
4175                 put_page(page);
4176                 rdata->pages[i] = NULL;
4177         }
4178         kref_put(&rdata->refcount, cifs_readdata_release);
4179 }
4180
4181 static int
4182 readpages_fill_pages(struct TCP_Server_Info *server,
4183                      struct cifs_readdata *rdata, struct iov_iter *iter,
4184                      unsigned int len)
4185 {
4186         int result = 0;
4187         unsigned int i;
4188         u64 eof;
4189         pgoff_t eof_index;
4190         unsigned int nr_pages = rdata->nr_pages;
4191         unsigned int page_offset = rdata->page_offset;
4192
4193         /* determine the eof that the server (probably) has */
4194         eof = CIFS_I(rdata->mapping->host)->server_eof;
4195         eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4196         cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4197
4198         rdata->got_bytes = 0;
4199         rdata->tailsz = PAGE_SIZE;
4200         for (i = 0; i < nr_pages; i++) {
4201                 struct page *page = rdata->pages[i];
4202                 unsigned int to_read = rdata->pagesz;
4203                 size_t n;
4204
4205                 if (i == 0)
4206                         to_read -= page_offset;
4207                 else
4208                         page_offset = 0;
4209
4210                 n = to_read;
4211
4212                 if (len >= to_read) {
4213                         len -= to_read;
4214                 } else if (len > 0) {
4215                         /* enough for partial page, fill and zero the rest */
4216                         zero_user(page, len + page_offset, to_read - len);
4217                         n = rdata->tailsz = len;
4218                         len = 0;
4219                 } else if (page->index > eof_index) {
4220                         /*
4221                          * The VFS will not try to do readahead past the
4222                          * i_size, but it's possible that we have outstanding
4223                          * writes with gaps in the middle and the i_size hasn't
4224                          * caught up yet. Populate those with zeroed out pages
4225                          * to prevent the VFS from repeatedly attempting to
4226                          * fill them until the writes are flushed.
4227                          */
4228                         zero_user(page, 0, PAGE_SIZE);
4229                         lru_cache_add_file(page);
4230                         flush_dcache_page(page);
4231                         SetPageUptodate(page);
4232                         unlock_page(page);
4233                         put_page(page);
4234                         rdata->pages[i] = NULL;
4235                         rdata->nr_pages--;
4236                         continue;
4237                 } else {
4238                         /* no need to hold page hostage */
4239                         lru_cache_add_file(page);
4240                         unlock_page(page);
4241                         put_page(page);
4242                         rdata->pages[i] = NULL;
4243                         rdata->nr_pages--;
4244                         continue;
4245                 }
4246
4247                 if (iter)
4248                         result = copy_page_from_iter(
4249                                         page, page_offset, n, iter);
4250 #ifdef CONFIG_CIFS_SMB_DIRECT
4251                 else if (rdata->mr)
4252                         result = n;
4253 #endif
4254                 else
4255                         result = cifs_read_page_from_socket(
4256                                         server, page, page_offset, n);
4257                 if (result < 0)
4258                         break;
4259
4260                 rdata->got_bytes += result;
4261         }
4262
4263         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
4264                                                 rdata->got_bytes : result;
4265 }
4266
4267 static int
4268 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4269                                struct cifs_readdata *rdata, unsigned int len)
4270 {
4271         return readpages_fill_pages(server, rdata, NULL, len);
4272 }
4273
4274 static int
4275 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4276                                struct cifs_readdata *rdata,
4277                                struct iov_iter *iter)
4278 {
4279         return readpages_fill_pages(server, rdata, iter, iter->count);
4280 }
4281
4282 static int
4283 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
4284                     unsigned int rsize, struct list_head *tmplist,
4285                     unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
4286 {
4287         struct page *page, *tpage;
4288         unsigned int expected_index;
4289         int rc;
4290         gfp_t gfp = readahead_gfp_mask(mapping);
4291
4292         INIT_LIST_HEAD(tmplist);
4293
4294         page = lru_to_page(page_list);
4295
4296         /*
4297          * Lock the page and put it in the cache. Since no one else
4298          * should have access to this page, we're safe to simply set
4299          * PG_locked without checking it first.
4300          */
4301         __SetPageLocked(page);
4302         rc = add_to_page_cache_locked(page, mapping,
4303                                       page->index, gfp);
4304
4305         /* give up if we can't stick it in the cache */
4306         if (rc) {
4307                 __ClearPageLocked(page);
4308                 return rc;
4309         }
4310
4311         /* move first page to the tmplist */
4312         *offset = (loff_t)page->index << PAGE_SHIFT;
4313         *bytes = PAGE_SIZE;
4314         *nr_pages = 1;
4315         list_move_tail(&page->lru, tmplist);
4316
4317         /* now try and add more pages onto the request */
4318         expected_index = page->index + 1;
4319         list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4320                 /* discontinuity ? */
4321                 if (page->index != expected_index)
4322                         break;
4323
4324                 /* would this page push the read over the rsize? */
4325                 if (*bytes + PAGE_SIZE > rsize)
4326                         break;
4327
4328                 __SetPageLocked(page);
4329                 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
4330                         __ClearPageLocked(page);
4331                         break;
4332                 }
4333                 list_move_tail(&page->lru, tmplist);
4334                 (*bytes) += PAGE_SIZE;
4335                 expected_index++;
4336                 (*nr_pages)++;
4337         }
4338         return rc;
4339 }
4340
4341 static int cifs_readpages(struct file *file, struct address_space *mapping,
4342         struct list_head *page_list, unsigned num_pages)
4343 {
4344         int rc;
4345         struct list_head tmplist;
4346         struct cifsFileInfo *open_file = file->private_data;
4347         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4348         struct TCP_Server_Info *server;
4349         pid_t pid;
4350         unsigned int xid;
4351
4352         xid = get_xid();
4353         /*
4354          * Reads as many pages as possible from fscache. Returns -ENOBUFS
4355          * immediately if the cookie is negative
4356          *
4357          * After this point, every page in the list might have PG_fscache set,
4358          * so we will need to clean that up off of every page we don't use.
4359          */
4360         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4361                                          &num_pages);
4362         if (rc == 0) {
4363                 free_xid(xid);
4364                 return rc;
4365         }
4366
4367         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4368                 pid = open_file->pid;
4369         else
4370                 pid = current->tgid;
4371
4372         rc = 0;
4373         server = tlink_tcon(open_file->tlink)->ses->server;
4374
4375         cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4376                  __func__, file, mapping, num_pages);
4377
4378         /*
4379          * Start with the page at end of list and move it to private
4380          * list. Do the same with any following pages until we hit
4381          * the rsize limit, hit an index discontinuity, or run out of
4382          * pages. Issue the async read and then start the loop again
4383          * until the list is empty.
4384          *
4385          * Note that list order is important. The page_list is in
4386          * the order of declining indexes. When we put the pages in
4387          * the rdata->pages, then we want them in increasing order.
4388          */
4389         while (!list_empty(page_list)) {
4390                 unsigned int i, nr_pages, bytes, rsize;
4391                 loff_t offset;
4392                 struct page *page, *tpage;
4393                 struct cifs_readdata *rdata;
4394                 struct cifs_credits credits_on_stack;
4395                 struct cifs_credits *credits = &credits_on_stack;
4396
4397                 if (open_file->invalidHandle) {
4398                         rc = cifs_reopen_file(open_file, true);
4399                         if (rc == -EAGAIN)
4400                                 continue;
4401                         else if (rc)
4402                                 break;
4403                 }
4404
4405                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
4406                                                    &rsize, credits);
4407                 if (rc)
4408                         break;
4409
4410                 /*
4411                  * Give up immediately if rsize is too small to read an entire
4412                  * page. The VFS will fall back to readpage. We should never
4413                  * reach this point however since we set ra_pages to 0 when the
4414                  * rsize is smaller than a cache page.
4415                  */
4416                 if (unlikely(rsize < PAGE_SIZE)) {
4417                         add_credits_and_wake_if(server, credits, 0);
4418                         free_xid(xid);
4419                         return 0;
4420                 }
4421
4422                 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4423                                          &nr_pages, &offset, &bytes);
4424                 if (rc) {
4425                         add_credits_and_wake_if(server, credits, 0);
4426                         break;
4427                 }
4428
4429                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4430                 if (!rdata) {
4431                         /* best to give up if we're out of mem */
4432                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4433                                 list_del(&page->lru);
4434                                 lru_cache_add_file(page);
4435                                 unlock_page(page);
4436                                 put_page(page);
4437                         }
4438                         rc = -ENOMEM;
4439                         add_credits_and_wake_if(server, credits, 0);
4440                         break;
4441                 }
4442
4443                 rdata->cfile = cifsFileInfo_get(open_file);
4444                 rdata->mapping = mapping;
4445                 rdata->offset = offset;
4446                 rdata->bytes = bytes;
4447                 rdata->pid = pid;
4448                 rdata->pagesz = PAGE_SIZE;
4449                 rdata->tailsz = PAGE_SIZE;
4450                 rdata->read_into_pages = cifs_readpages_read_into_pages;
4451                 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4452                 rdata->credits = credits_on_stack;
4453
4454                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4455                         list_del(&page->lru);
4456                         rdata->pages[rdata->nr_pages++] = page;
4457                 }
4458
4459                 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4460
4461                 if (!rc) {
4462                         if (rdata->cfile->invalidHandle)
4463                                 rc = -EAGAIN;
4464                         else
4465                                 rc = server->ops->async_readv(rdata);
4466                 }
4467
4468                 if (rc) {
4469                         add_credits_and_wake_if(server, &rdata->credits, 0);
4470                         for (i = 0; i < rdata->nr_pages; i++) {
4471                                 page = rdata->pages[i];
4472                                 lru_cache_add_file(page);
4473                                 unlock_page(page);
4474                                 put_page(page);
4475                         }
4476                         /* Fallback to the readpage in error/reconnect cases */
4477                         kref_put(&rdata->refcount, cifs_readdata_release);
4478                         break;
4479                 }
4480
4481                 kref_put(&rdata->refcount, cifs_readdata_release);
4482         }
4483
4484         /* Any pages that have been shown to fscache but didn't get added to
4485          * the pagecache must be uncached before they get returned to the
4486          * allocator.
4487          */
4488         cifs_fscache_readpages_cancel(mapping->host, page_list);
4489         free_xid(xid);
4490         return rc;
4491 }
4492
4493 /*
4494  * cifs_readpage_worker must be called with the page pinned
4495  */
4496 static int cifs_readpage_worker(struct file *file, struct page *page,
4497         loff_t *poffset)
4498 {
4499         char *read_data;
4500         int rc;
4501
4502         /* Is the page cached? */
4503         rc = cifs_readpage_from_fscache(file_inode(file), page);
4504         if (rc == 0)
4505                 goto read_complete;
4506
4507         read_data = kmap(page);
4508         /* for reads over a certain size could initiate async read ahead */
4509
4510         rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4511
4512         if (rc < 0)
4513                 goto io_error;
4514         else
4515                 cifs_dbg(FYI, "Bytes read %d\n", rc);
4516
4517         /* we do not want atime to be less than mtime, it broke some apps */
4518         file_inode(file)->i_atime = current_time(file_inode(file));
4519         if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4520                 file_inode(file)->i_atime = file_inode(file)->i_mtime;
4521         else
4522                 file_inode(file)->i_atime = current_time(file_inode(file));
4523
4524         if (PAGE_SIZE > rc)
4525                 memset(read_data + rc, 0, PAGE_SIZE - rc);
4526
4527         flush_dcache_page(page);
4528         SetPageUptodate(page);
4529
4530         /* send this page to the cache */
4531         cifs_readpage_to_fscache(file_inode(file), page);
4532
4533         rc = 0;
4534
4535 io_error:
4536         kunmap(page);
4537         unlock_page(page);
4538
4539 read_complete:
4540         return rc;
4541 }
4542
4543 static int cifs_readpage(struct file *file, struct page *page)
4544 {
4545         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
4546         int rc = -EACCES;
4547         unsigned int xid;
4548
4549         xid = get_xid();
4550
4551         if (file->private_data == NULL) {
4552                 rc = -EBADF;
4553                 free_xid(xid);
4554                 return rc;
4555         }
4556
4557         cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4558                  page, (int)offset, (int)offset);
4559
4560         rc = cifs_readpage_worker(file, page, &offset);
4561
4562         free_xid(xid);
4563         return rc;
4564 }
4565
4566 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4567 {
4568         struct cifsFileInfo *open_file;
4569
4570         spin_lock(&cifs_inode->open_file_lock);
4571         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4572                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4573                         spin_unlock(&cifs_inode->open_file_lock);
4574                         return 1;
4575                 }
4576         }
4577         spin_unlock(&cifs_inode->open_file_lock);
4578         return 0;
4579 }
4580
4581 /* We do not want to update the file size from server for inodes
4582    open for write - to avoid races with writepage extending
4583    the file - in the future we could consider allowing
4584    refreshing the inode only on increases in the file size
4585    but this is tricky to do without racing with writebehind
4586    page caching in the current Linux kernel design */
4587 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4588 {
4589         if (!cifsInode)
4590                 return true;
4591
4592         if (is_inode_writable(cifsInode)) {
4593                 /* This inode is open for write at least once */
4594                 struct cifs_sb_info *cifs_sb;
4595
4596                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
4597                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4598                         /* since no page cache to corrupt on directio
4599                         we can change size safely */
4600                         return true;
4601                 }
4602
4603                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4604                         return true;
4605
4606                 return false;
4607         } else
4608                 return true;
4609 }
4610
4611 static int cifs_write_begin(struct file *file, struct address_space *mapping,
4612                         loff_t pos, unsigned len, unsigned flags,
4613                         struct page **pagep, void **fsdata)
4614 {
4615         int oncethru = 0;
4616         pgoff_t index = pos >> PAGE_SHIFT;
4617         loff_t offset = pos & (PAGE_SIZE - 1);
4618         loff_t page_start = pos & PAGE_MASK;
4619         loff_t i_size;
4620         struct page *page;
4621         int rc = 0;
4622
4623         cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4624
4625 start:
4626         page = grab_cache_page_write_begin(mapping, index, flags);
4627         if (!page) {
4628                 rc = -ENOMEM;
4629                 goto out;
4630         }
4631
4632         if (PageUptodate(page))
4633                 goto out;
4634
4635         /*
4636          * If we write a full page it will be up to date, no need to read from
4637          * the server. If the write is short, we'll end up doing a sync write
4638          * instead.
4639          */
4640         if (len == PAGE_SIZE)
4641                 goto out;
4642
4643         /*
4644          * optimize away the read when we have an oplock, and we're not
4645          * expecting to use any of the data we'd be reading in. That
4646          * is, when the page lies beyond the EOF, or straddles the EOF
4647          * and the write will cover all of the existing data.
4648          */
4649         if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4650                 i_size = i_size_read(mapping->host);
4651                 if (page_start >= i_size ||
4652                     (offset == 0 && (pos + len) >= i_size)) {
4653                         zero_user_segments(page, 0, offset,
4654                                            offset + len,
4655                                            PAGE_SIZE);
4656                         /*
4657                          * PageChecked means that the parts of the page
4658                          * to which we're not writing are considered up
4659                          * to date. Once the data is copied to the
4660                          * page, it can be set uptodate.
4661                          */
4662                         SetPageChecked(page);
4663                         goto out;
4664                 }
4665         }
4666
4667         if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4668                 /*
4669                  * might as well read a page, it is fast enough. If we get
4670                  * an error, we don't need to return it. cifs_write_end will
4671                  * do a sync write instead since PG_uptodate isn't set.
4672                  */
4673                 cifs_readpage_worker(file, page, &page_start);
4674                 put_page(page);
4675                 oncethru = 1;
4676                 goto start;
4677         } else {
4678                 /* we could try using another file handle if there is one -
4679                    but how would we lock it to prevent close of that handle
4680                    racing with this read? In any case
4681                    this will be written out by write_end so is fine */
4682         }
4683 out:
4684         *pagep = page;
4685         return rc;
4686 }
4687
4688 static int cifs_release_page(struct page *page, gfp_t gfp)
4689 {
4690         if (PagePrivate(page))
4691                 return 0;
4692
4693         return cifs_fscache_release_page(page, gfp);
4694 }
4695
4696 static void cifs_invalidate_page(struct page *page, unsigned int offset,
4697                                  unsigned int length)
4698 {
4699         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4700
4701         if (offset == 0 && length == PAGE_SIZE)
4702                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4703 }
4704
4705 static int cifs_launder_page(struct page *page)
4706 {
4707         int rc = 0;
4708         loff_t range_start = page_offset(page);
4709         loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4710         struct writeback_control wbc = {
4711                 .sync_mode = WB_SYNC_ALL,
4712                 .nr_to_write = 0,
4713                 .range_start = range_start,
4714                 .range_end = range_end,
4715         };
4716
4717         cifs_dbg(FYI, "Launder page: %p\n", page);
4718
4719         if (clear_page_dirty_for_io(page))
4720                 rc = cifs_writepage_locked(page, &wbc);
4721
4722         cifs_fscache_invalidate_page(page, page->mapping->host);
4723         return rc;
4724 }
4725
4726 void cifs_oplock_break(struct work_struct *work)
4727 {
4728         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4729                                                   oplock_break);
4730         struct inode *inode = d_inode(cfile->dentry);
4731         struct cifsInodeInfo *cinode = CIFS_I(inode);
4732         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4733         struct TCP_Server_Info *server = tcon->ses->server;
4734         int rc = 0;
4735         bool purge_cache = false;
4736
4737         wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4738                         TASK_UNINTERRUPTIBLE);
4739
4740         server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,
4741                                       cfile->oplock_epoch, &purge_cache);
4742
4743         if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4744                                                 cifs_has_mand_locks(cinode)) {
4745                 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4746                          inode);
4747                 cinode->oplock = 0;
4748         }
4749
4750         if (inode && S_ISREG(inode->i_mode)) {
4751                 if (CIFS_CACHE_READ(cinode))
4752                         break_lease(inode, O_RDONLY);
4753                 else
4754                         break_lease(inode, O_WRONLY);
4755                 rc = filemap_fdatawrite(inode->i_mapping);
4756                 if (!CIFS_CACHE_READ(cinode) || purge_cache) {
4757                         rc = filemap_fdatawait(inode->i_mapping);
4758                         mapping_set_error(inode->i_mapping, rc);
4759                         cifs_zap_mapping(inode);
4760                 }
4761                 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4762                 if (CIFS_CACHE_WRITE(cinode))
4763                         goto oplock_break_ack;
4764         }
4765
4766         rc = cifs_push_locks(cfile);
4767         if (rc)
4768                 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4769
4770 oplock_break_ack:
4771         /*
4772          * releasing stale oplock after recent reconnect of smb session using
4773          * a now incorrect file handle is not a data integrity issue but do
4774          * not bother sending an oplock release if session to server still is
4775          * disconnected since oplock already released by the server
4776          */
4777         if (!cfile->oplock_break_cancelled) {
4778                 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4779                                                              cinode);
4780                 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4781         }
4782         _cifsFileInfo_put(cfile, false /* do not wait for ourself */, false);
4783         cifs_done_oplock_break(cinode);
4784 }
4785
4786 /*
4787  * The presence of cifs_direct_io() in the address space ops vector
4788  * allowes open() O_DIRECT flags which would have failed otherwise.
4789  *
4790  * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4791  * so this method should never be called.
4792  *
4793  * Direct IO is not yet supported in the cached mode.
4794  */
4795 static ssize_t
4796 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4797 {
4798         /*
4799          * FIXME
4800          * Eventually need to support direct IO for non forcedirectio mounts
4801          */
4802         return -EINVAL;
4803 }
4804
4805
4806 const struct address_space_operations cifs_addr_ops = {
4807         .readpage = cifs_readpage,
4808         .readpages = cifs_readpages,
4809         .writepage = cifs_writepage,
4810         .writepages = cifs_writepages,
4811         .write_begin = cifs_write_begin,
4812         .write_end = cifs_write_end,
4813         .set_page_dirty = __set_page_dirty_nobuffers,
4814         .releasepage = cifs_release_page,
4815         .direct_IO = cifs_direct_io,
4816         .invalidatepage = cifs_invalidate_page,
4817         .launder_page = cifs_launder_page,
4818 };
4819
4820 /*
4821  * cifs_readpages requires the server to support a buffer large enough to
4822  * contain the header plus one complete page of data.  Otherwise, we need
4823  * to leave cifs_readpages out of the address space operations.
4824  */
4825 const struct address_space_operations cifs_addr_ops_smallbuf = {
4826         .readpage = cifs_readpage,
4827         .writepage = cifs_writepage,
4828         .writepages = cifs_writepages,
4829         .write_begin = cifs_write_begin,
4830         .write_end = cifs_write_end,
4831         .set_page_dirty = __set_page_dirty_nobuffers,
4832         .releasepage = cifs_release_page,
4833         .invalidatepage = cifs_invalidate_page,
4834         .launder_page = cifs_launder_page,
4835 };