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