fs/cifs/file.c

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