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