fs/cifs/file.c

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