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