fs/cifs/file.c

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