fs/cifs/file.c

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