kernel/fs/cifs/file.c

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