fs/cifs/file.c

   1 /*
   2  *   fs/cifs/file.c
   3  *
   4  *   vfs operations that deal with files
   5  *
   6  *   Copyright (C) International Business Machines  Corp., 2002,2010
   7  *   Author(s): Steve French (sfrench@us.ibm.com)
   8  *              Jeremy Allison (jra@samba.org)
   9  *
  10  *   This library is free software; you can redistribute it and/or modify
  11  *   it under the terms of the GNU Lesser General Public License as published
  12  *   by the Free Software Foundation; either version 2.1 of the License, or
  13  *   (at your option) any later version.
  14  *
  15  *   This library is distributed in the hope that it will be useful,
  16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  18  *   the GNU Lesser General Public License for more details.
  19  *
  20  *   You should have received a copy of the GNU Lesser General Public License
  21  *   along with this library; if not, write to the Free Software
  22  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23  */
  24 #include <linux/fs.h>
  25 #include <linux/backing-dev.h>
  26 #include <linux/stat.h>
  27 #include <linux/fcntl.h>
  28 #include <linux/pagemap.h>
  29 #include <linux/pagevec.h>
  30 #include <linux/writeback.h>
  31 #include <linux/task_io_accounting_ops.h>
  32 #include <linux/delay.h>
  33 #include <linux/mount.h>
  34 #include <linux/slab.h>
  35 #include <linux/swap.h>
  36 #include <asm/div64.h>
  37 #include "cifsfs.h"
  38 #include "cifspdu.h"
  39 #include "cifsglob.h"
  40 #include "cifsproto.h"
  41 #include "cifs_unicode.h"
  42 #include "cifs_debug.h"
  43 #include "cifs_fs_sb.h"
  44 #include "fscache.h"
  45
  46 static inline int cifs_convert_flags(unsigned int flags)
  47 {
  48         if ((flags & O_ACCMODE) == O_RDONLY)
  49                 return GENERIC_READ;
  50         else if ((flags & O_ACCMODE) == O_WRONLY)
  51                 return GENERIC_WRITE;
  52         else if ((flags & O_ACCMODE) == O_RDWR) {
  53                 /* GENERIC_ALL is too much permission to request
  54                    can cause unnecessary access denied on create */
  55                 /* return GENERIC_ALL; */
  56                 return (GENERIC_READ | GENERIC_WRITE);
  57         }
  58
  59         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  60                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  61                 FILE_READ_DATA);
  62 }
  63
  64 static u32 cifs_posix_convert_flags(unsigned int flags)
  65 {
  66         u32 posix_flags = 0;
  67
  68         if ((flags & O_ACCMODE) == O_RDONLY)
  69                 posix_flags = SMB_O_RDONLY;
  70         else if ((flags & O_ACCMODE) == O_WRONLY)
  71                 posix_flags = SMB_O_WRONLY;
  72         else if ((flags & O_ACCMODE) == O_RDWR)
  73                 posix_flags = SMB_O_RDWR;
  74
  75         if (flags & O_CREAT)
  76                 posix_flags |= SMB_O_CREAT;
  77         if (flags & O_EXCL)
  78                 posix_flags |= SMB_O_EXCL;
  79         if (flags & O_TRUNC)
  80                 posix_flags |= SMB_O_TRUNC;
  81         /* be safe and imply O_SYNC for O_DSYNC */
  82         if (flags & O_DSYNC)
  83                 posix_flags |= SMB_O_SYNC;
  84         if (flags & O_DIRECTORY)
  85                 posix_flags |= SMB_O_DIRECTORY;
  86         if (flags & O_NOFOLLOW)
  87                 posix_flags |= SMB_O_NOFOLLOW;
  88         if (flags & O_DIRECT)
  89                 posix_flags |= SMB_O_DIRECT;
  90
  91         return posix_flags;
  92 }
  93
  94 static inline int cifs_get_disposition(unsigned int flags)
  95 {
  96         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
  97                 return FILE_CREATE;
  98         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
  99                 return FILE_OVERWRITE_IF;
 100         else if ((flags & O_CREAT) == O_CREAT)
 101                 return FILE_OPEN_IF;
 102         else if ((flags & O_TRUNC) == O_TRUNC)
 103                 return FILE_OVERWRITE;
 104         else
 105                 return FILE_OPEN;
 106 }
 107
 108 int cifs_posix_open(char *full_path, struct inode **pinode,
 109                         struct super_block *sb, int mode, unsigned int f_flags,
 110                         __u32 *poplock, __u16 *pnetfid, int xid)
 111 {
 112         int rc;
 113         FILE_UNIX_BASIC_INFO *presp_data;
 114         __u32 posix_flags = 0;
 115         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 116         struct cifs_fattr fattr;
 117         struct tcon_link *tlink;
 118         struct cifs_tcon *tcon;
 119
 120         cFYI(1, "posix open %s", full_path);
 121
 122         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 123         if (presp_data == NULL)
 124                 return -ENOMEM;
 125
 126         tlink = cifs_sb_tlink(cifs_sb);
 127         if (IS_ERR(tlink)) {
 128                 rc = PTR_ERR(tlink);
 129                 goto posix_open_ret;
 130         }
 131
 132         tcon = tlink_tcon(tlink);
 133         mode &= ~current_umask();
 134
 135         posix_flags = cifs_posix_convert_flags(f_flags);
 136         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 137                              poplock, full_path, cifs_sb->local_nls,
 138                              cifs_sb->mnt_cifs_flags &
 139                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 140         cifs_put_tlink(tlink);
 141
 142         if (rc)
 143                 goto posix_open_ret;
 144
 145         if (presp_data->Type == cpu_to_le32(-1))
 146                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 147
 148         if (!pinode)
 149                 goto posix_open_ret; /* caller does not need info */
 150
 151         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 152
 153         /* get new inode and set it up */
 154         if (*pinode == NULL) {
 155                 cifs_fill_uniqueid(sb, &fattr);
 156                 *pinode = cifs_iget(sb, &fattr);
 157                 if (!*pinode) {
 158                         rc = -ENOMEM;
 159                         goto posix_open_ret;
 160                 }
 161         } else {
 162                 cifs_fattr_to_inode(*pinode, &fattr);
 163         }
 164
 165 posix_open_ret:
 166         kfree(presp_data);
 167         return rc;
 168 }
 169
 170 static int
 171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 172              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
 173              __u16 *pnetfid, int xid)
 174 {
 175         int rc;
 176         int desiredAccess;
 177         int disposition;
 178         int create_options = CREATE_NOT_DIR;
 179         FILE_ALL_INFO *buf;
 180
 181         desiredAccess = cifs_convert_flags(f_flags);
 182
 183 /*********************************************************************
 184  *  open flag mapping table:
 185  *
 186  *      POSIX Flag            CIFS Disposition
 187  *      ----------            ----------------
 188  *      O_CREAT               FILE_OPEN_IF
 189  *      O_CREAT | O_EXCL      FILE_CREATE
 190  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 191  *      O_TRUNC               FILE_OVERWRITE
 192  *      none of the above     FILE_OPEN
 193  *
 194  *      Note that there is not a direct match between disposition
 195  *      FILE_SUPERSEDE (ie create whether or not file exists although
 196  *      O_CREAT | O_TRUNC is similar but truncates the existing
 197  *      file rather than creating a new file as FILE_SUPERSEDE does
 198  *      (which uses the attributes / metadata passed in on open call)
 199  *?
 200  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 201  *?  and the read write flags match reasonably.  O_LARGEFILE
 202  *?  is irrelevant because largefile support is always used
 203  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 204  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 205  *********************************************************************/
 206
 207         disposition = cifs_get_disposition(f_flags);
 208
 209         /* BB pass O_SYNC flag through on file attributes .. BB */
 210
 211         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 212         if (!buf)
 213                 return -ENOMEM;
 214
 215         if (backup_cred(cifs_sb))
 216                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 217
 218         if (tcon->ses->capabilities & CAP_NT_SMBS)
 219                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 220                          desiredAccess, create_options, pnetfid, poplock, buf,
 221                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 222                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
 223         else
 224                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 225                         desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
 226                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 227                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
 228
 229         if (rc)
 230                 goto out;
 231
 232         if (tcon->unix_ext)
 233                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 234                                               xid);
 235         else
 236                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 237                                          xid, pnetfid);
 238
 239 out:
 240         kfree(buf);
 241         return rc;
 242 }
 243
 244 struct cifsFileInfo *
 245 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
 246                   struct tcon_link *tlink, __u32 oplock)
 247 {
 248         struct dentry *dentry = file->f_path.dentry;
 249         struct inode *inode = dentry->d_inode;
 250         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
 251         struct cifsFileInfo *pCifsFile;
 252
 253         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 254         if (pCifsFile == NULL)
 255                 return pCifsFile;
 256
 257         pCifsFile->count = 1;
 258         pCifsFile->netfid = fileHandle;
 259         pCifsFile->pid = current->tgid;
 260         pCifsFile->uid = current_fsuid();
 261         pCifsFile->dentry = dget(dentry);
 262         pCifsFile->f_flags = file->f_flags;
 263         pCifsFile->invalidHandle = false;
 264         pCifsFile->tlink = cifs_get_tlink(tlink);
 265         mutex_init(&pCifsFile->fh_mutex);
 266         INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
 267
 268         spin_lock(&cifs_file_list_lock);
 269         list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
 270         /* if readable file instance put first in list*/
 271         if (file->f_mode & FMODE_READ)
 272                 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
 273         else
 274                 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
 275         spin_unlock(&cifs_file_list_lock);
 276
 277         cifs_set_oplock_level(pCifsInode, oplock);
 278         pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
 279
 280         file->private_data = pCifsFile;
 281         return pCifsFile;
 282 }
 283
 284 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
 285
 286 /*
 287  * Release a reference on the file private data. This may involve closing
 288  * the filehandle out on the server. Must be called without holding
 289  * cifs_file_list_lock.
 290  */
 291 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 292 {
 293         struct inode *inode = cifs_file->dentry->d_inode;
 294         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 295         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 296         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 297         struct cifsLockInfo *li, *tmp;
 298
 299         spin_lock(&cifs_file_list_lock);
 300         if (--cifs_file->count > 0) {
 301                 spin_unlock(&cifs_file_list_lock);
 302                 return;
 303         }
 304
 305         /* remove it from the lists */
 306         list_del(&cifs_file->flist);
 307         list_del(&cifs_file->tlist);
 308
 309         if (list_empty(&cifsi->openFileList)) {
 310                 cFYI(1, "closing last open instance for inode %p",
 311                         cifs_file->dentry->d_inode);
 312
 313                 /* in strict cache mode we need invalidate mapping on the last
 314                    close  because it may cause a error when we open this file
 315                    again and get at least level II oplock */
 316                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 317                         CIFS_I(inode)->invalid_mapping = true;
 318
 319                 cifs_set_oplock_level(cifsi, 0);
 320         }
 321         spin_unlock(&cifs_file_list_lock);
 322
 323         cancel_work_sync(&cifs_file->oplock_break);
 324
 325         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 326                 int xid, rc;
 327
 328                 xid = GetXid();
 329                 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
 330                 FreeXid(xid);
 331         }
 332
 333         /* Delete any outstanding lock records. We'll lose them when the file
 334          * is closed anyway.
 335          */
 336         mutex_lock(&cifsi->lock_mutex);
 337         list_for_each_entry_safe(li, tmp, &cifsi->llist, llist) {
 338                 if (li->netfid != cifs_file->netfid)
 339                         continue;
 340                 list_del(&li->llist);
 341                 cifs_del_lock_waiters(li);
 342                 kfree(li);
 343         }
 344         mutex_unlock(&cifsi->lock_mutex);
 345
 346         cifs_put_tlink(cifs_file->tlink);
 347         dput(cifs_file->dentry);
 348         kfree(cifs_file);
 349 }
 350
 351 int cifs_open(struct inode *inode, struct file *file)
 352 {
 353         int rc = -EACCES;
 354         int xid;
 355         __u32 oplock;
 356         struct cifs_sb_info *cifs_sb;
 357         struct cifs_tcon *tcon;
 358         struct tcon_link *tlink;
 359         struct cifsFileInfo *pCifsFile = NULL;
 360         char *full_path = NULL;
 361         bool posix_open_ok = false;
 362         __u16 netfid;
 363
 364         xid = GetXid();
 365
 366         cifs_sb = CIFS_SB(inode->i_sb);
 367         tlink = cifs_sb_tlink(cifs_sb);
 368         if (IS_ERR(tlink)) {
 369                 FreeXid(xid);
 370                 return PTR_ERR(tlink);
 371         }
 372         tcon = tlink_tcon(tlink);
 373
 374         full_path = build_path_from_dentry(file->f_path.dentry);
 375         if (full_path == NULL) {
 376                 rc = -ENOMEM;
 377                 goto out;
 378         }
 379
 380         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
 381                  inode, file->f_flags, full_path);
 382
 383         if (enable_oplocks)
 384                 oplock = REQ_OPLOCK;
 385         else
 386                 oplock = 0;
 387
 388         if (!tcon->broken_posix_open && tcon->unix_ext &&
 389             (tcon->ses->capabilities & CAP_UNIX) &&
 390             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 391                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 392                 /* can not refresh inode info since size could be stale */
 393                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 394                                 cifs_sb->mnt_file_mode /* ignored */,
 395                                 file->f_flags, &oplock, &netfid, xid);
 396                 if (rc == 0) {
 397                         cFYI(1, "posix open succeeded");
 398                         posix_open_ok = true;
 399                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 400                         if (tcon->ses->serverNOS)
 401                                 cERROR(1, "server %s of type %s returned"
 402                                            " unexpected error on SMB posix open"
 403                                            ", disabling posix open support."
 404                                            " Check if server update available.",
 405                                            tcon->ses->serverName,
 406                                            tcon->ses->serverNOS);
 407                         tcon->broken_posix_open = true;
 408                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 409                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 410                         goto out;
 411                 /* else fallthrough to retry open the old way on network i/o
 412                    or DFS errors */
 413         }
 414
 415         if (!posix_open_ok) {
 416                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 417                                   file->f_flags, &oplock, &netfid, xid);
 418                 if (rc)
 419                         goto out;
 420         }
 421
 422         pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
 423         if (pCifsFile == NULL) {
 424                 CIFSSMBClose(xid, tcon, netfid);
 425                 rc = -ENOMEM;
 426                 goto out;
 427         }
 428
 429         cifs_fscache_set_inode_cookie(inode, file);
 430
 431         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 432                 /* time to set mode which we can not set earlier due to
 433                    problems creating new read-only files */
 434                 struct cifs_unix_set_info_args args = {
 435                         .mode   = inode->i_mode,
 436                         .uid    = NO_CHANGE_64,
 437                         .gid    = NO_CHANGE_64,
 438                         .ctime  = NO_CHANGE_64,
 439                         .atime  = NO_CHANGE_64,
 440                         .mtime  = NO_CHANGE_64,
 441                         .device = 0,
 442                 };
 443                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
 444                                         pCifsFile->pid);
 445         }
 446
 447 out:
 448         kfree(full_path);
 449         FreeXid(xid);
 450         cifs_put_tlink(tlink);
 451         return rc;
 452 }
 453
 454 /* Try to reacquire byte range locks that were released when session */
 455 /* to server was lost */
 456 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
 457 {
 458         int rc = 0;
 459
 460 /* BB list all locks open on this file and relock */
 461
 462         return rc;
 463 }
 464
 465 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
 466 {
 467         int rc = -EACCES;
 468         int xid;
 469         __u32 oplock;
 470         struct cifs_sb_info *cifs_sb;
 471         struct cifs_tcon *tcon;
 472         struct cifsInodeInfo *pCifsInode;
 473         struct inode *inode;
 474         char *full_path = NULL;
 475         int desiredAccess;
 476         int disposition = FILE_OPEN;
 477         int create_options = CREATE_NOT_DIR;
 478         __u16 netfid;
 479
 480         xid = GetXid();
 481         mutex_lock(&pCifsFile->fh_mutex);
 482         if (!pCifsFile->invalidHandle) {
 483                 mutex_unlock(&pCifsFile->fh_mutex);
 484                 rc = 0;
 485                 FreeXid(xid);
 486                 return rc;
 487         }
 488
 489         inode = pCifsFile->dentry->d_inode;
 490         cifs_sb = CIFS_SB(inode->i_sb);
 491         tcon = tlink_tcon(pCifsFile->tlink);
 492
 493 /* can not grab rename sem here because various ops, including
 494    those that already have the rename sem can end up causing writepage
 495    to get called and if the server was down that means we end up here,
 496    and we can never tell if the caller already has the rename_sem */
 497         full_path = build_path_from_dentry(pCifsFile->dentry);
 498         if (full_path == NULL) {
 499                 rc = -ENOMEM;
 500                 mutex_unlock(&pCifsFile->fh_mutex);
 501                 FreeXid(xid);
 502                 return rc;
 503         }
 504
 505         cFYI(1, "inode = 0x%p file flags 0x%x for %s",
 506                  inode, pCifsFile->f_flags, full_path);
 507
 508         if (enable_oplocks)
 509                 oplock = REQ_OPLOCK;
 510         else
 511                 oplock = 0;
 512
 513         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 514             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 515                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 516
 517                 /*
 518                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 519                  * original open. Must mask them off for a reopen.
 520                  */
 521                 unsigned int oflags = pCifsFile->f_flags &
 522                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 523
 524                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 525                                 cifs_sb->mnt_file_mode /* ignored */,
 526                                 oflags, &oplock, &netfid, xid);
 527                 if (rc == 0) {
 528                         cFYI(1, "posix reopen succeeded");
 529                         goto reopen_success;
 530                 }
 531                 /* fallthrough to retry open the old way on errors, especially
 532                    in the reconnect path it is important to retry hard */
 533         }
 534
 535         desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
 536
 537         if (backup_cred(cifs_sb))
 538                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 539
 540         /* Can not refresh inode by passing in file_info buf to be returned
 541            by SMBOpen and then calling get_inode_info with returned buf
 542            since file might have write behind data that needs to be flushed
 543            and server version of file size can be stale. If we knew for sure
 544            that inode was not dirty locally we could do this */
 545
 546         rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
 547                          create_options, &netfid, &oplock, NULL,
 548                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 549                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 550         if (rc) {
 551                 mutex_unlock(&pCifsFile->fh_mutex);
 552                 cFYI(1, "cifs_open returned 0x%x", rc);
 553                 cFYI(1, "oplock: %d", oplock);
 554                 goto reopen_error_exit;
 555         }
 556
 557 reopen_success:
 558         pCifsFile->netfid = netfid;
 559         pCifsFile->invalidHandle = false;
 560         mutex_unlock(&pCifsFile->fh_mutex);
 561         pCifsInode = CIFS_I(inode);
 562
 563         if (can_flush) {
 564                 rc = filemap_write_and_wait(inode->i_mapping);
 565                 mapping_set_error(inode->i_mapping, rc);
 566
 567                 if (tcon->unix_ext)
 568                         rc = cifs_get_inode_info_unix(&inode,
 569                                 full_path, inode->i_sb, xid);
 570                 else
 571                         rc = cifs_get_inode_info(&inode,
 572                                 full_path, NULL, inode->i_sb,
 573                                 xid, NULL);
 574         } /* else we are writing out data to server already
 575              and could deadlock if we tried to flush data, and
 576              since we do not know if we have data that would
 577              invalidate the current end of file on the server
 578              we can not go to the server to get the new inod
 579              info */
 580
 581         cifs_set_oplock_level(pCifsInode, oplock);
 582
 583         cifs_relock_file(pCifsFile);
 584
 585 reopen_error_exit:
 586         kfree(full_path);
 587         FreeXid(xid);
 588         return rc;
 589 }
 590
 591 int cifs_close(struct inode *inode, struct file *file)
 592 {
 593         if (file->private_data != NULL) {
 594                 cifsFileInfo_put(file->private_data);
 595                 file->private_data = NULL;
 596         }
 597
 598         /* return code from the ->release op is always ignored */
 599         return 0;
 600 }
 601
 602 int cifs_closedir(struct inode *inode, struct file *file)
 603 {
 604         int rc = 0;
 605         int xid;
 606         struct cifsFileInfo *pCFileStruct = file->private_data;
 607         char *ptmp;
 608
 609         cFYI(1, "Closedir inode = 0x%p", inode);
 610
 611         xid = GetXid();
 612
 613         if (pCFileStruct) {
 614                 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
 615
 616                 cFYI(1, "Freeing private data in close dir");
 617                 spin_lock(&cifs_file_list_lock);
 618                 if (!pCFileStruct->srch_inf.endOfSearch &&
 619                     !pCFileStruct->invalidHandle) {
 620                         pCFileStruct->invalidHandle = true;
 621                         spin_unlock(&cifs_file_list_lock);
 622                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 623                         cFYI(1, "Closing uncompleted readdir with rc %d",
 624                                  rc);
 625                         /* not much we can do if it fails anyway, ignore rc */
 626                         rc = 0;
 627                 } else
 628                         spin_unlock(&cifs_file_list_lock);
 629                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 630                 if (ptmp) {
 631                         cFYI(1, "closedir free smb buf in srch struct");
 632                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 633                         if (pCFileStruct->srch_inf.smallBuf)
 634                                 cifs_small_buf_release(ptmp);
 635                         else
 636                                 cifs_buf_release(ptmp);
 637                 }
 638                 cifs_put_tlink(pCFileStruct->tlink);
 639                 kfree(file->private_data);
 640                 file->private_data = NULL;
 641         }
 642         /* BB can we lock the filestruct while this is going on? */
 643         FreeXid(xid);
 644         return rc;
 645 }
 646
 647 static struct cifsLockInfo *
 648 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 netfid)
 649 {
 650         struct cifsLockInfo *lock =
 651                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 652         if (!lock)
 653                 return lock;
 654         lock->offset = offset;
 655         lock->length = length;
 656         lock->type = type;
 657         lock->netfid = netfid;
 658         lock->pid = current->tgid;
 659         INIT_LIST_HEAD(&lock->blist);
 660         init_waitqueue_head(&lock->block_q);
 661         return lock;
 662 }
 663
 664 static void
 665 cifs_del_lock_waiters(struct cifsLockInfo *lock)
 666 {
 667         struct cifsLockInfo *li, *tmp;
 668         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
 669                 list_del_init(&li->blist);
 670                 wake_up(&li->block_q);
 671         }
 672 }
 673
 674 static bool
 675 __cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
 676                         __u64 length, __u8 type, __u16 netfid,
 677                         struct cifsLockInfo **conf_lock)
 678 {
 679         struct cifsLockInfo *li, *tmp;
 680
 681         list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
 682                 if (offset + length <= li->offset ||
 683                     offset >= li->offset + li->length)
 684                         continue;
 685                 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
 686                          ((netfid == li->netfid && current->tgid == li->pid) ||
 687                           type == li->type))
 688                         continue;
 689                 else {
 690                         *conf_lock = li;
 691                         return true;
 692                 }
 693         }
 694         return false;
 695 }
 696
 697 static bool
 698 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
 699                         struct cifsLockInfo **conf_lock)
 700 {
 701         return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
 702                                          lock->type, lock->netfid, conf_lock);
 703 }
 704
 705 static int
 706 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
 707                __u8 type, __u16 netfid, struct file_lock *flock)
 708 {
 709         int rc = 0;
 710         struct cifsLockInfo *conf_lock;
 711         bool exist;
 712
 713         mutex_lock(&cinode->lock_mutex);
 714
 715         exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
 716                                           &conf_lock);
 717         if (exist) {
 718                 flock->fl_start = conf_lock->offset;
 719                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
 720                 flock->fl_pid = conf_lock->pid;
 721                 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
 722                         flock->fl_type = F_RDLCK;
 723                 else
 724                         flock->fl_type = F_WRLCK;
 725         } else if (!cinode->can_cache_brlcks)
 726                 rc = 1;
 727         else
 728                 flock->fl_type = F_UNLCK;
 729
 730         mutex_unlock(&cinode->lock_mutex);
 731         return rc;
 732 }
 733
 734 static void
 735 cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
 736 {
 737         mutex_lock(&cinode->lock_mutex);
 738         list_add_tail(&lock->llist, &cinode->llist);
 739         mutex_unlock(&cinode->lock_mutex);
 740 }
 741
 742 static int
 743 cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
 744                  bool wait)
 745 {
 746         struct cifsLockInfo *conf_lock;
 747         bool exist;
 748         int rc = 0;
 749
 750 try_again:
 751         exist = false;
 752         mutex_lock(&cinode->lock_mutex);
 753
 754         exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
 755         if (!exist && cinode->can_cache_brlcks) {
 756                 list_add_tail(&lock->llist, &cinode->llist);
 757                 mutex_unlock(&cinode->lock_mutex);
 758                 return rc;
 759         }
 760
 761         if (!exist)
 762                 rc = 1;
 763         else if (!wait)
 764                 rc = -EACCES;
 765         else {
 766                 list_add_tail(&lock->blist, &conf_lock->blist);
 767                 mutex_unlock(&cinode->lock_mutex);
 768                 rc = wait_event_interruptible(lock->block_q,
 769                                         (lock->blist.prev == &lock->blist) &&
 770                                         (lock->blist.next == &lock->blist));
 771                 if (!rc)
 772                         goto try_again;
 773                 mutex_lock(&cinode->lock_mutex);
 774                 list_del_init(&lock->blist);
 775         }
 776
 777         mutex_unlock(&cinode->lock_mutex);
 778         return rc;
 779 }
 780
 781 static int
 782 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 783 {
 784         int rc = 0;
 785         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 786         unsigned char saved_type = flock->fl_type;
 787
 788         if ((flock->fl_flags & FL_POSIX) == 0)
 789                 return 1;
 790
 791         mutex_lock(&cinode->lock_mutex);
 792         posix_test_lock(file, flock);
 793
 794         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
 795                 flock->fl_type = saved_type;
 796                 rc = 1;
 797         }
 798
 799         mutex_unlock(&cinode->lock_mutex);
 800         return rc;
 801 }
 802
 803 static int
 804 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
 805 {
 806         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 807         int rc = 1;
 808
 809         if ((flock->fl_flags & FL_POSIX) == 0)
 810                 return rc;
 811
 812         mutex_lock(&cinode->lock_mutex);
 813         if (!cinode->can_cache_brlcks) {
 814                 mutex_unlock(&cinode->lock_mutex);
 815                 return rc;
 816         }
 817         rc = posix_lock_file_wait(file, flock);
 818         mutex_unlock(&cinode->lock_mutex);
 819         return rc;
 820 }
 821
 822 static int
 823 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
 824 {
 825         int xid, rc = 0, stored_rc;
 826         struct cifsLockInfo *li, *tmp;
 827         struct cifs_tcon *tcon;
 828         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 829         unsigned int num, max_num;
 830         LOCKING_ANDX_RANGE *buf, *cur;
 831         int types[] = {LOCKING_ANDX_LARGE_FILES,
 832                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
 833         int i;
 834
 835         xid = GetXid();
 836         tcon = tlink_tcon(cfile->tlink);
 837
 838         mutex_lock(&cinode->lock_mutex);
 839         if (!cinode->can_cache_brlcks) {
 840                 mutex_unlock(&cinode->lock_mutex);
 841                 FreeXid(xid);
 842                 return rc;
 843         }
 844
 845         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
 846                   sizeof(LOCKING_ANDX_RANGE);
 847         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
 848         if (!buf) {
 849                 mutex_unlock(&cinode->lock_mutex);
 850                 FreeXid(xid);
 851                 return rc;
 852         }
 853
 854         for (i = 0; i < 2; i++) {
 855                 cur = buf;
 856                 num = 0;
 857                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
 858                         if (li->type != types[i])
 859                                 continue;
 860                         cur->Pid = cpu_to_le16(li->pid);
 861                         cur->LengthLow = cpu_to_le32((u32)li->length);
 862                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
 863                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
 864                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
 865                         if (++num == max_num) {
 866                                 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 867                                                        li->type, 0, num, buf);
 868                                 if (stored_rc)
 869                                         rc = stored_rc;
 870                                 cur = buf;
 871                                 num = 0;
 872                         } else
 873                                 cur++;
 874                 }
 875
 876                 if (num) {
 877                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 878                                                types[i], 0, num, buf);
 879                         if (stored_rc)
 880                                 rc = stored_rc;
 881                 }
 882         }
 883
 884         cinode->can_cache_brlcks = false;
 885         mutex_unlock(&cinode->lock_mutex);
 886
 887         kfree(buf);
 888         FreeXid(xid);
 889         return rc;
 890 }
 891
 892 /* copied from fs/locks.c with a name change */
 893 #define cifs_for_each_lock(inode, lockp) \
 894         for (lockp = &inode->i_flock; *lockp != NULL; \
 895              lockp = &(*lockp)->fl_next)
 896
 897 static int
 898 cifs_push_posix_locks(struct cifsFileInfo *cfile)
 899 {
 900         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 901         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 902         struct file_lock *flock, **before;
 903         struct cifsLockInfo *lck, *tmp;
 904         int rc = 0, xid, type;
 905         __u64 length;
 906         struct list_head locks_to_send;
 907
 908         xid = GetXid();
 909
 910         mutex_lock(&cinode->lock_mutex);
 911         if (!cinode->can_cache_brlcks) {
 912                 mutex_unlock(&cinode->lock_mutex);
 913                 FreeXid(xid);
 914                 return rc;
 915         }
 916
 917         INIT_LIST_HEAD(&locks_to_send);
 918
 919         lock_flocks();
 920         cifs_for_each_lock(cfile->dentry->d_inode, before) {
 921                 flock = *before;
 922                 length = 1 + flock->fl_end - flock->fl_start;
 923                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
 924                         type = CIFS_RDLCK;
 925                 else
 926                         type = CIFS_WRLCK;
 927
 928                 lck = cifs_lock_init(flock->fl_start, length, type,
 929                                      cfile->netfid);
 930                 if (!lck) {
 931                         rc = -ENOMEM;
 932                         goto send_locks;
 933                 }
 934                 lck->pid = flock->fl_pid;
 935
 936                 list_add_tail(&lck->llist, &locks_to_send);
 937         }
 938
 939 send_locks:
 940         unlock_flocks();
 941
 942         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
 943                 struct file_lock tmp_lock;
 944                 int stored_rc;
 945
 946                 tmp_lock.fl_start = lck->offset;
 947                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
 948                                              0, lck->length, &tmp_lock,
 949                                              lck->type, 0);
 950                 if (stored_rc)
 951                         rc = stored_rc;
 952                 list_del(&lck->llist);
 953                 kfree(lck);
 954         }
 955
 956         cinode->can_cache_brlcks = false;
 957         mutex_unlock(&cinode->lock_mutex);
 958
 959         FreeXid(xid);
 960         return rc;
 961 }
 962
 963 static int
 964 cifs_push_locks(struct cifsFileInfo *cfile)
 965 {
 966         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
 967         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 968
 969         if ((tcon->ses->capabilities & CAP_UNIX) &&
 970             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 971             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 972                 return cifs_push_posix_locks(cfile);
 973
 974         return cifs_push_mandatory_locks(cfile);
 975 }
 976
 977 static void
 978 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
 979                 bool *wait_flag)
 980 {
 981         if (flock->fl_flags & FL_POSIX)
 982                 cFYI(1, "Posix");
 983         if (flock->fl_flags & FL_FLOCK)
 984                 cFYI(1, "Flock");
 985         if (flock->fl_flags & FL_SLEEP) {
 986                 cFYI(1, "Blocking lock");
 987                 *wait_flag = true;
 988         }
 989         if (flock->fl_flags & FL_ACCESS)
 990                 cFYI(1, "Process suspended by mandatory locking - "
 991                         "not implemented yet");
 992         if (flock->fl_flags & FL_LEASE)
 993                 cFYI(1, "Lease on file - not implemented yet");
 994         if (flock->fl_flags &
 995             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
 996                 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
 997
 998         *type = LOCKING_ANDX_LARGE_FILES;
 999         if (flock->fl_type == F_WRLCK) {
1000                 cFYI(1, "F_WRLCK ");
1001                 *lock = 1;
1002         } else if (flock->fl_type == F_UNLCK) {
1003                 cFYI(1, "F_UNLCK");
1004                 *unlock = 1;
1005                 /* Check if unlock includes more than one lock range */
1006         } else if (flock->fl_type == F_RDLCK) {
1007                 cFYI(1, "F_RDLCK");
1008                 *type |= LOCKING_ANDX_SHARED_LOCK;
1009                 *lock = 1;
1010         } else if (flock->fl_type == F_EXLCK) {
1011                 cFYI(1, "F_EXLCK");
1012                 *lock = 1;
1013         } else if (flock->fl_type == F_SHLCK) {
1014                 cFYI(1, "F_SHLCK");
1015                 *type |= LOCKING_ANDX_SHARED_LOCK;
1016                 *lock = 1;
1017         } else
1018                 cFYI(1, "Unknown type of lock");
1019 }
1020
1021 static int
1022 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1023            bool wait_flag, bool posix_lck, int xid)
1024 {
1025         int rc = 0;
1026         __u64 length = 1 + flock->fl_end - flock->fl_start;
1027         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1028         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1029         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1030         __u16 netfid = cfile->netfid;
1031
1032         if (posix_lck) {
1033                 int posix_lock_type;
1034
1035                 rc = cifs_posix_lock_test(file, flock);
1036                 if (!rc)
1037                         return rc;
1038
1039                 if (type & LOCKING_ANDX_SHARED_LOCK)
1040                         posix_lock_type = CIFS_RDLCK;
1041                 else
1042                         posix_lock_type = CIFS_WRLCK;
1043                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1044                                       1 /* get */, length, flock,
1045                                       posix_lock_type, wait_flag);
1046                 return rc;
1047         }
1048
1049         rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1050                             flock);
1051         if (!rc)
1052                 return rc;
1053
1054         /* BB we could chain these into one lock request BB */
1055         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1056                          flock->fl_start, 0, 1, type, 0, 0);
1057         if (rc == 0) {
1058                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1059                                  length, flock->fl_start, 1, 0,
1060                                  type, 0, 0);
1061                 flock->fl_type = F_UNLCK;
1062                 if (rc != 0)
1063                         cERROR(1, "Error unlocking previously locked "
1064                                    "range %d during test of lock", rc);
1065                 return 0;
1066         }
1067
1068         if (type & LOCKING_ANDX_SHARED_LOCK) {
1069                 flock->fl_type = F_WRLCK;
1070                 return 0;
1071         }
1072
1073         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1074                          flock->fl_start, 0, 1,
1075                          type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1076         if (rc == 0) {
1077                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1078                                  length, flock->fl_start, 1, 0,
1079                                  type | LOCKING_ANDX_SHARED_LOCK,
1080                                  0, 0);
1081                 flock->fl_type = F_RDLCK;
1082                 if (rc != 0)
1083                         cERROR(1, "Error unlocking previously locked "
1084                                   "range %d during test of lock", rc);
1085         } else
1086                 flock->fl_type = F_WRLCK;
1087
1088         return 0;
1089 }
1090
1091 static void
1092 cifs_move_llist(struct list_head *source, struct list_head *dest)
1093 {
1094         struct list_head *li, *tmp;
1095         list_for_each_safe(li, tmp, source)
1096                 list_move(li, dest);
1097 }
1098
1099 static void
1100 cifs_free_llist(struct list_head *llist)
1101 {
1102         struct cifsLockInfo *li, *tmp;
1103         list_for_each_entry_safe(li, tmp, llist, llist) {
1104                 cifs_del_lock_waiters(li);
1105                 list_del(&li->llist);
1106                 kfree(li);
1107         }
1108 }
1109
1110 static int
1111 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1112 {
1113         int rc = 0, stored_rc;
1114         int types[] = {LOCKING_ANDX_LARGE_FILES,
1115                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1116         unsigned int i;
1117         unsigned int max_num, num;
1118         LOCKING_ANDX_RANGE *buf, *cur;
1119         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1120         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1121         struct cifsLockInfo *li, *tmp;
1122         __u64 length = 1 + flock->fl_end - flock->fl_start;
1123         struct list_head tmp_llist;
1124
1125         INIT_LIST_HEAD(&tmp_llist);
1126
1127         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1128                   sizeof(LOCKING_ANDX_RANGE);
1129         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1130         if (!buf)
1131                 return -ENOMEM;
1132
1133         mutex_lock(&cinode->lock_mutex);
1134         for (i = 0; i < 2; i++) {
1135                 cur = buf;
1136                 num = 0;
1137                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1138                         if (flock->fl_start > li->offset ||
1139                             (flock->fl_start + length) <
1140                             (li->offset + li->length))
1141                                 continue;
1142                         if (current->tgid != li->pid)
1143                                 continue;
1144                         if (cfile->netfid != li->netfid)
1145                                 continue;
1146                         if (types[i] != li->type)
1147                                 continue;
1148                         if (!cinode->can_cache_brlcks) {
1149                                 cur->Pid = cpu_to_le16(li->pid);
1150                                 cur->LengthLow = cpu_to_le32((u32)li->length);
1151                                 cur->LengthHigh =
1152                                         cpu_to_le32((u32)(li->length>>32));
1153                                 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1154                                 cur->OffsetHigh =
1155                                         cpu_to_le32((u32)(li->offset>>32));
1156                                 /*
1157                                  * We need to save a lock here to let us add
1158                                  * it again to the inode list if the unlock
1159                                  * range request fails on the server.
1160                                  */
1161                                 list_move(&li->llist, &tmp_llist);
1162                                 if (++num == max_num) {
1163                                         stored_rc = cifs_lockv(xid, tcon,
1164                                                                cfile->netfid,
1165                                                                li->type, num,
1166                                                                0, buf);
1167                                         if (stored_rc) {
1168                                                 /*
1169                                                  * We failed on the unlock range
1170                                                  * request - add all locks from
1171                                                  * the tmp list to the head of
1172                                                  * the inode list.
1173                                                  */
1174                                                 cifs_move_llist(&tmp_llist,
1175                                                                 &cinode->llist);
1176                                                 rc = stored_rc;
1177                                         } else
1178                                                 /*
1179                                                  * The unlock range request
1180                                                  * succeed - free the tmp list.
1181                                                  */
1182                                                 cifs_free_llist(&tmp_llist);
1183                                         cur = buf;
1184                                         num = 0;
1185                                 } else
1186                                         cur++;
1187                         } else {
1188                                 /*
1189                                  * We can cache brlock requests - simply remove
1190                                  * a lock from the inode list.
1191                                  */
1192                                 list_del(&li->llist);
1193                                 cifs_del_lock_waiters(li);
1194                                 kfree(li);
1195                         }
1196                 }
1197                 if (num) {
1198                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1199                                                types[i], num, 0, buf);
1200                         if (stored_rc) {
1201                                 cifs_move_llist(&tmp_llist, &cinode->llist);
1202                                 rc = stored_rc;
1203                         } else
1204                                 cifs_free_llist(&tmp_llist);
1205                 }
1206         }
1207
1208         mutex_unlock(&cinode->lock_mutex);
1209         kfree(buf);
1210         return rc;
1211 }
1212
1213 static int
1214 cifs_setlk(struct file *file,  struct file_lock *flock, __u8 type,
1215            bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1216 {
1217         int rc = 0;
1218         __u64 length = 1 + flock->fl_end - flock->fl_start;
1219         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1220         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1221         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1222         __u16 netfid = cfile->netfid;
1223
1224         if (posix_lck) {
1225                 int posix_lock_type;
1226
1227                 rc = cifs_posix_lock_set(file, flock);
1228                 if (!rc || rc < 0)
1229                         return rc;
1230
1231                 if (type & LOCKING_ANDX_SHARED_LOCK)
1232                         posix_lock_type = CIFS_RDLCK;
1233                 else
1234                         posix_lock_type = CIFS_WRLCK;
1235
1236                 if (unlock == 1)
1237                         posix_lock_type = CIFS_UNLCK;
1238
1239                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1240                                       0 /* set */, length, flock,
1241                                       posix_lock_type, wait_flag);
1242                 goto out;
1243         }
1244
1245         if (lock) {
1246                 struct cifsLockInfo *lock;
1247
1248                 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1249                 if (!lock)
1250                         return -ENOMEM;
1251
1252                 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1253                 if (rc < 0)
1254                         kfree(lock);
1255                 if (rc <= 0)
1256                         goto out;
1257
1258                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1259                                  flock->fl_start, 0, 1, type, wait_flag, 0);
1260                 if (rc) {
1261                         kfree(lock);
1262                         goto out;
1263                 }
1264
1265                 cifs_lock_add(cinode, lock);
1266         } else if (unlock)
1267                 rc = cifs_unlock_range(cfile, flock, xid);
1268
1269 out:
1270         if (flock->fl_flags & FL_POSIX)
1271                 posix_lock_file_wait(file, flock);
1272         return rc;
1273 }
1274
1275 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1276 {
1277         int rc, xid;
1278         int lock = 0, unlock = 0;
1279         bool wait_flag = false;
1280         bool posix_lck = false;
1281         struct cifs_sb_info *cifs_sb;
1282         struct cifs_tcon *tcon;
1283         struct cifsInodeInfo *cinode;
1284         struct cifsFileInfo *cfile;
1285         __u16 netfid;
1286         __u8 type;
1287
1288         rc = -EACCES;
1289         xid = GetXid();
1290
1291         cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1292                 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1293                 flock->fl_start, flock->fl_end);
1294
1295         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1296
1297         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1298         cfile = (struct cifsFileInfo *)file->private_data;
1299         tcon = tlink_tcon(cfile->tlink);
1300         netfid = cfile->netfid;
1301         cinode = CIFS_I(file->f_path.dentry->d_inode);
1302
1303         if ((tcon->ses->capabilities & CAP_UNIX) &&
1304             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1305             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1306                 posix_lck = true;
1307         /*
1308          * BB add code here to normalize offset and length to account for
1309          * negative length which we can not accept over the wire.
1310          */
1311         if (IS_GETLK(cmd)) {
1312                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1313                 FreeXid(xid);
1314                 return rc;
1315         }
1316
1317         if (!lock && !unlock) {
1318                 /*
1319                  * if no lock or unlock then nothing to do since we do not
1320                  * know what it is
1321                  */
1322                 FreeXid(xid);
1323                 return -EOPNOTSUPP;
1324         }
1325
1326         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1327                         xid);
1328         FreeXid(xid);
1329         return rc;
1330 }
1331
1332 /* update the file size (if needed) after a write */
1333 void
1334 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1335                       unsigned int bytes_written)
1336 {
1337         loff_t end_of_write = offset + bytes_written;
1338
1339         if (end_of_write > cifsi->server_eof)
1340                 cifsi->server_eof = end_of_write;
1341 }
1342
1343 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1344                           const char *write_data, size_t write_size,
1345                           loff_t *poffset)
1346 {
1347         int rc = 0;
1348         unsigned int bytes_written = 0;
1349         unsigned int total_written;
1350         struct cifs_sb_info *cifs_sb;
1351         struct cifs_tcon *pTcon;
1352         int xid;
1353         struct dentry *dentry = open_file->dentry;
1354         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1355         struct cifs_io_parms io_parms;
1356
1357         cifs_sb = CIFS_SB(dentry->d_sb);
1358
1359         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1360            *poffset, dentry->d_name.name);
1361
1362         pTcon = tlink_tcon(open_file->tlink);
1363
1364         xid = GetXid();
1365
1366         for (total_written = 0; write_size > total_written;
1367              total_written += bytes_written) {
1368                 rc = -EAGAIN;
1369                 while (rc == -EAGAIN) {
1370                         struct kvec iov[2];
1371                         unsigned int len;
1372
1373                         if (open_file->invalidHandle) {
1374                                 /* we could deadlock if we called
1375                                    filemap_fdatawait from here so tell
1376                                    reopen_file not to flush data to
1377                                    server now */
1378                                 rc = cifs_reopen_file(open_file, false);
1379                                 if (rc != 0)
1380                                         break;
1381                         }
1382
1383                         len = min((size_t)cifs_sb->wsize,
1384                                   write_size - total_written);
1385                         /* iov[0] is reserved for smb header */
1386                         iov[1].iov_base = (char *)write_data + total_written;
1387                         iov[1].iov_len = len;
1388                         io_parms.netfid = open_file->netfid;
1389                         io_parms.pid = pid;
1390                         io_parms.tcon = pTcon;
1391                         io_parms.offset = *poffset;
1392                         io_parms.length = len;
1393                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1394                                            1, 0);
1395                 }
1396                 if (rc || (bytes_written == 0)) {
1397                         if (total_written)
1398                                 break;
1399                         else {
1400                                 FreeXid(xid);
1401                                 return rc;
1402                         }
1403                 } else {
1404                         cifs_update_eof(cifsi, *poffset, bytes_written);
1405                         *poffset += bytes_written;
1406                 }
1407         }
1408
1409         cifs_stats_bytes_written(pTcon, total_written);
1410
1411         if (total_written > 0) {
1412                 spin_lock(&dentry->d_inode->i_lock);
1413                 if (*poffset > dentry->d_inode->i_size)
1414                         i_size_write(dentry->d_inode, *poffset);
1415                 spin_unlock(&dentry->d_inode->i_lock);
1416         }
1417         mark_inode_dirty_sync(dentry->d_inode);
1418         FreeXid(xid);
1419         return total_written;
1420 }
1421
1422 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1423                                         bool fsuid_only)
1424 {
1425         struct cifsFileInfo *open_file = NULL;
1426         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1427
1428         /* only filter by fsuid on multiuser mounts */
1429         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1430                 fsuid_only = false;
1431
1432         spin_lock(&cifs_file_list_lock);
1433         /* we could simply get the first_list_entry since write-only entries
1434            are always at the end of the list but since the first entry might
1435            have a close pending, we go through the whole list */
1436         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1437                 if (fsuid_only && open_file->uid != current_fsuid())
1438                         continue;
1439                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1440                         if (!open_file->invalidHandle) {
1441                                 /* found a good file */
1442                                 /* lock it so it will not be closed on us */
1443                                 cifsFileInfo_get(open_file);
1444                                 spin_unlock(&cifs_file_list_lock);
1445                                 return open_file;
1446                         } /* else might as well continue, and look for
1447                              another, or simply have the caller reopen it
1448                              again rather than trying to fix this handle */
1449                 } else /* write only file */
1450                         break; /* write only files are last so must be done */
1451         }
1452         spin_unlock(&cifs_file_list_lock);
1453         return NULL;
1454 }
1455
1456 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1457                                         bool fsuid_only)
1458 {
1459         struct cifsFileInfo *open_file;
1460         struct cifs_sb_info *cifs_sb;
1461         bool any_available = false;
1462         int rc;
1463
1464         /* Having a null inode here (because mapping->host was set to zero by
1465         the VFS or MM) should not happen but we had reports of on oops (due to
1466         it being zero) during stress testcases so we need to check for it */
1467
1468         if (cifs_inode == NULL) {
1469                 cERROR(1, "Null inode passed to cifs_writeable_file");
1470                 dump_stack();
1471                 return NULL;
1472         }
1473
1474         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1475
1476         /* only filter by fsuid on multiuser mounts */
1477         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1478                 fsuid_only = false;
1479
1480         spin_lock(&cifs_file_list_lock);
1481 refind_writable:
1482         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1483                 if (!any_available && open_file->pid != current->tgid)
1484                         continue;
1485                 if (fsuid_only && open_file->uid != current_fsuid())
1486                         continue;
1487                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1488                         cifsFileInfo_get(open_file);
1489
1490                         if (!open_file->invalidHandle) {
1491                                 /* found a good writable file */
1492                                 spin_unlock(&cifs_file_list_lock);
1493                                 return open_file;
1494                         }
1495
1496                         spin_unlock(&cifs_file_list_lock);
1497
1498                         /* Had to unlock since following call can block */
1499                         rc = cifs_reopen_file(open_file, false);
1500                         if (!rc)
1501                                 return open_file;
1502
1503                         /* if it fails, try another handle if possible */
1504                         cFYI(1, "wp failed on reopen file");
1505                         cifsFileInfo_put(open_file);
1506
1507                         spin_lock(&cifs_file_list_lock);
1508
1509                         /* else we simply continue to the next entry. Thus
1510                            we do not loop on reopen errors.  If we
1511                            can not reopen the file, for example if we
1512                            reconnected to a server with another client
1513                            racing to delete or lock the file we would not
1514                            make progress if we restarted before the beginning
1515                            of the loop here. */
1516                 }
1517         }
1518         /* couldn't find useable FH with same pid, try any available */
1519         if (!any_available) {
1520                 any_available = true;
1521                 goto refind_writable;
1522         }
1523         spin_unlock(&cifs_file_list_lock);
1524         return NULL;
1525 }
1526
1527 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1528 {
1529         struct address_space *mapping = page->mapping;
1530         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1531         char *write_data;
1532         int rc = -EFAULT;
1533         int bytes_written = 0;
1534         struct inode *inode;
1535         struct cifsFileInfo *open_file;
1536
1537         if (!mapping || !mapping->host)
1538                 return -EFAULT;
1539
1540         inode = page->mapping->host;
1541
1542         offset += (loff_t)from;
1543         write_data = kmap(page);
1544         write_data += from;
1545
1546         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1547                 kunmap(page);
1548                 return -EIO;
1549         }
1550
1551         /* racing with truncate? */
1552         if (offset > mapping->host->i_size) {
1553                 kunmap(page);
1554                 return 0; /* don't care */
1555         }
1556
1557         /* check to make sure that we are not extending the file */
1558         if (mapping->host->i_size - offset < (loff_t)to)
1559                 to = (unsigned)(mapping->host->i_size - offset);
1560
1561         open_file = find_writable_file(CIFS_I(mapping->host), false);
1562         if (open_file) {
1563                 bytes_written = cifs_write(open_file, open_file->pid,
1564                                            write_data, to - from, &offset);
1565                 cifsFileInfo_put(open_file);
1566                 /* Does mm or vfs already set times? */
1567                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1568                 if ((bytes_written > 0) && (offset))
1569                         rc = 0;
1570                 else if (bytes_written < 0)
1571                         rc = bytes_written;
1572         } else {
1573                 cFYI(1, "No writeable filehandles for inode");
1574                 rc = -EIO;
1575         }
1576
1577         kunmap(page);
1578         return rc;
1579 }
1580
1581 static int cifs_writepages(struct address_space *mapping,
1582                            struct writeback_control *wbc)
1583 {
1584         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1585         bool done = false, scanned = false, range_whole = false;
1586         pgoff_t end, index;
1587         struct cifs_writedata *wdata;
1588         struct page *page;
1589         int rc = 0;
1590
1591         /*
1592          * If wsize is smaller than the page cache size, default to writing
1593          * one page at a time via cifs_writepage
1594          */
1595         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1596                 return generic_writepages(mapping, wbc);
1597
1598         if (wbc->range_cyclic) {
1599                 index = mapping->writeback_index; /* Start from prev offset */
1600                 end = -1;
1601         } else {
1602                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1603                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1604                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1605                         range_whole = true;
1606                 scanned = true;
1607         }
1608 retry:
1609         while (!done && index <= end) {
1610                 unsigned int i, nr_pages, found_pages;
1611                 pgoff_t next = 0, tofind;
1612                 struct page **pages;
1613
1614                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1615                                 end - index) + 1;
1616
1617                 wdata = cifs_writedata_alloc((unsigned int)tofind);
1618                 if (!wdata) {
1619                         rc = -ENOMEM;
1620                         break;
1621                 }
1622
1623                 /*
1624                  * find_get_pages_tag seems to return a max of 256 on each
1625                  * iteration, so we must call it several times in order to
1626                  * fill the array or the wsize is effectively limited to
1627                  * 256 * PAGE_CACHE_SIZE.
1628                  */
1629                 found_pages = 0;
1630                 pages = wdata->pages;
1631                 do {
1632                         nr_pages = find_get_pages_tag(mapping, &index,
1633                                                         PAGECACHE_TAG_DIRTY,
1634                                                         tofind, pages);
1635                         found_pages += nr_pages;
1636                         tofind -= nr_pages;
1637                         pages += nr_pages;
1638                 } while (nr_pages && tofind && index <= end);
1639
1640                 if (found_pages == 0) {
1641                         kref_put(&wdata->refcount, cifs_writedata_release);
1642                         break;
1643                 }
1644
1645                 nr_pages = 0;
1646                 for (i = 0; i < found_pages; i++) {
1647                         page = wdata->pages[i];
1648                         /*
1649                          * At this point we hold neither mapping->tree_lock nor
1650                          * lock on the page itself: the page may be truncated or
1651                          * invalidated (changing page->mapping to NULL), or even
1652                          * swizzled back from swapper_space to tmpfs file
1653                          * mapping
1654                          */
1655
1656                         if (nr_pages == 0)
1657                                 lock_page(page);
1658                         else if (!trylock_page(page))
1659                                 break;
1660
1661                         if (unlikely(page->mapping != mapping)) {
1662                                 unlock_page(page);
1663                                 break;
1664                         }
1665
1666                         if (!wbc->range_cyclic && page->index > end) {
1667                                 done = true;
1668                                 unlock_page(page);
1669                                 break;
1670                         }
1671
1672                         if (next && (page->index != next)) {
1673                                 /* Not next consecutive page */
1674                                 unlock_page(page);
1675                                 break;
1676                         }
1677
1678                         if (wbc->sync_mode != WB_SYNC_NONE)
1679                                 wait_on_page_writeback(page);
1680
1681                         if (PageWriteback(page) ||
1682                                         !clear_page_dirty_for_io(page)) {
1683                                 unlock_page(page);
1684                                 break;
1685                         }
1686
1687                         /*
1688                          * This actually clears the dirty bit in the radix tree.
1689                          * See cifs_writepage() for more commentary.
1690                          */
1691                         set_page_writeback(page);
1692
1693                         if (page_offset(page) >= mapping->host->i_size) {
1694                                 done = true;
1695                                 unlock_page(page);
1696                                 end_page_writeback(page);
1697                                 break;
1698                         }
1699
1700                         wdata->pages[i] = page;
1701                         next = page->index + 1;
1702                         ++nr_pages;
1703                 }
1704
1705                 /* reset index to refind any pages skipped */
1706                 if (nr_pages == 0)
1707                         index = wdata->pages[0]->index + 1;
1708
1709                 /* put any pages we aren't going to use */
1710                 for (i = nr_pages; i < found_pages; i++) {
1711                         page_cache_release(wdata->pages[i]);
1712                         wdata->pages[i] = NULL;
1713                 }
1714
1715                 /* nothing to write? */
1716                 if (nr_pages == 0) {
1717                         kref_put(&wdata->refcount, cifs_writedata_release);
1718                         continue;
1719                 }
1720
1721                 wdata->sync_mode = wbc->sync_mode;
1722                 wdata->nr_pages = nr_pages;
1723                 wdata->offset = page_offset(wdata->pages[0]);
1724
1725                 do {
1726                         if (wdata->cfile != NULL)
1727                                 cifsFileInfo_put(wdata->cfile);
1728                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1729                                                           false);
1730                         if (!wdata->cfile) {
1731                                 cERROR(1, "No writable handles for inode");
1732                                 rc = -EBADF;
1733                                 break;
1734                         }
1735                         rc = cifs_async_writev(wdata);
1736                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1737
1738                 for (i = 0; i < nr_pages; ++i)
1739                         unlock_page(wdata->pages[i]);
1740
1741                 /* send failure -- clean up the mess */
1742                 if (rc != 0) {
1743                         for (i = 0; i < nr_pages; ++i) {
1744                                 if (rc == -EAGAIN)
1745                                         redirty_page_for_writepage(wbc,
1746                                                            wdata->pages[i]);
1747                                 else
1748                                         SetPageError(wdata->pages[i]);
1749                                 end_page_writeback(wdata->pages[i]);
1750                                 page_cache_release(wdata->pages[i]);
1751                         }
1752                         if (rc != -EAGAIN)
1753                                 mapping_set_error(mapping, rc);
1754                 }
1755                 kref_put(&wdata->refcount, cifs_writedata_release);
1756
1757                 wbc->nr_to_write -= nr_pages;
1758                 if (wbc->nr_to_write <= 0)
1759                         done = true;
1760
1761                 index = next;
1762         }
1763
1764         if (!scanned && !done) {
1765                 /*
1766                  * We hit the last page and there is more work to be done: wrap
1767                  * back to the start of the file
1768                  */
1769                 scanned = true;
1770                 index = 0;
1771                 goto retry;
1772         }
1773
1774         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1775                 mapping->writeback_index = index;
1776
1777         return rc;
1778 }
1779
1780 static int
1781 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1782 {
1783         int rc;
1784         int xid;
1785
1786         xid = GetXid();
1787 /* BB add check for wbc flags */
1788         page_cache_get(page);
1789         if (!PageUptodate(page))
1790                 cFYI(1, "ppw - page not up to date");
1791
1792         /*
1793          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1794          *
1795          * A writepage() implementation always needs to do either this,
1796          * or re-dirty the page with "redirty_page_for_writepage()" in
1797          * the case of a failure.
1798          *
1799          * Just unlocking the page will cause the radix tree tag-bits
1800          * to fail to update with the state of the page correctly.
1801          */
1802         set_page_writeback(page);
1803 retry_write:
1804         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1805         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1806                 goto retry_write;
1807         else if (rc == -EAGAIN)
1808                 redirty_page_for_writepage(wbc, page);
1809         else if (rc != 0)
1810                 SetPageError(page);
1811         else
1812                 SetPageUptodate(page);
1813         end_page_writeback(page);
1814         page_cache_release(page);
1815         FreeXid(xid);
1816         return rc;
1817 }
1818
1819 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1820 {
1821         int rc = cifs_writepage_locked(page, wbc);
1822         unlock_page(page);
1823         return rc;
1824 }
1825
1826 static int cifs_write_end(struct file *file, struct address_space *mapping,
1827                         loff_t pos, unsigned len, unsigned copied,
1828                         struct page *page, void *fsdata)
1829 {
1830         int rc;
1831         struct inode *inode = mapping->host;
1832         struct cifsFileInfo *cfile = file->private_data;
1833         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1834         __u32 pid;
1835
1836         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1837                 pid = cfile->pid;
1838         else
1839                 pid = current->tgid;
1840
1841         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1842                  page, pos, copied);
1843
1844         if (PageChecked(page)) {
1845                 if (copied == len)
1846                         SetPageUptodate(page);
1847                 ClearPageChecked(page);
1848         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1849                 SetPageUptodate(page);
1850
1851         if (!PageUptodate(page)) {
1852                 char *page_data;
1853                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1854                 int xid;
1855
1856                 xid = GetXid();
1857                 /* this is probably better than directly calling
1858                    partialpage_write since in this function the file handle is
1859                    known which we might as well leverage */
1860                 /* BB check if anything else missing out of ppw
1861                    such as updating last write time */
1862                 page_data = kmap(page);
1863                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1864                 /* if (rc < 0) should we set writebehind rc? */
1865                 kunmap(page);
1866
1867                 FreeXid(xid);
1868         } else {
1869                 rc = copied;
1870                 pos += copied;
1871                 set_page_dirty(page);
1872         }
1873
1874         if (rc > 0) {
1875                 spin_lock(&inode->i_lock);
1876                 if (pos > inode->i_size)
1877                         i_size_write(inode, pos);
1878                 spin_unlock(&inode->i_lock);
1879         }
1880
1881         unlock_page(page);
1882         page_cache_release(page);
1883
1884         return rc;
1885 }
1886
1887 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1888                       int datasync)
1889 {
1890         int xid;
1891         int rc = 0;
1892         struct cifs_tcon *tcon;
1893         struct cifsFileInfo *smbfile = file->private_data;
1894         struct inode *inode = file->f_path.dentry->d_inode;
1895         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1896
1897         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1898         if (rc)
1899                 return rc;
1900         mutex_lock(&inode->i_mutex);
1901
1902         xid = GetXid();
1903
1904         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1905                 file->f_path.dentry->d_name.name, datasync);
1906
1907         if (!CIFS_I(inode)->clientCanCacheRead) {
1908                 rc = cifs_invalidate_mapping(inode);
1909                 if (rc) {
1910                         cFYI(1, "rc: %d during invalidate phase", rc);
1911                         rc = 0; /* don't care about it in fsync */
1912                 }
1913         }
1914
1915         tcon = tlink_tcon(smbfile->tlink);
1916         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1917                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1918
1919         FreeXid(xid);
1920         mutex_unlock(&inode->i_mutex);
1921         return rc;
1922 }
1923
1924 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1925 {
1926         int xid;
1927         int rc = 0;
1928         struct cifs_tcon *tcon;
1929         struct cifsFileInfo *smbfile = file->private_data;
1930         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1931         struct inode *inode = file->f_mapping->host;
1932
1933         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1934         if (rc)
1935                 return rc;
1936         mutex_lock(&inode->i_mutex);
1937
1938         xid = GetXid();
1939
1940         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1941                 file->f_path.dentry->d_name.name, datasync);
1942
1943         tcon = tlink_tcon(smbfile->tlink);
1944         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1945                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1946
1947         FreeXid(xid);
1948         mutex_unlock(&inode->i_mutex);
1949         return rc;
1950 }
1951
1952 /*
1953  * As file closes, flush all cached write data for this inode checking
1954  * for write behind errors.
1955  */
1956 int cifs_flush(struct file *file, fl_owner_t id)
1957 {
1958         struct inode *inode = file->f_path.dentry->d_inode;
1959         int rc = 0;
1960
1961         if (file->f_mode & FMODE_WRITE)
1962                 rc = filemap_write_and_wait(inode->i_mapping);
1963
1964         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1965
1966         return rc;
1967 }
1968
1969 static int
1970 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
1971 {
1972         int rc = 0;
1973         unsigned long i;
1974
1975         for (i = 0; i < num_pages; i++) {
1976                 pages[i] = alloc_page(__GFP_HIGHMEM);
1977                 if (!pages[i]) {
1978                         /*
1979                          * save number of pages we have already allocated and
1980                          * return with ENOMEM error
1981                          */
1982                         num_pages = i;
1983                         rc = -ENOMEM;
1984                         goto error;
1985                 }
1986         }
1987
1988         return rc;
1989
1990 error:
1991         for (i = 0; i < num_pages; i++)
1992                 put_page(pages[i]);
1993         return rc;
1994 }
1995
1996 static inline
1997 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
1998 {
1999         size_t num_pages;
2000         size_t clen;
2001
2002         clen = min_t(const size_t, len, wsize);
2003         num_pages = clen / PAGE_CACHE_SIZE;
2004         if (clen % PAGE_CACHE_SIZE)
2005                 num_pages++;
2006
2007         if (cur_len)
2008                 *cur_len = clen;
2009
2010         return num_pages;
2011 }
2012
2013 static ssize_t
2014 cifs_iovec_write(struct file *file, const struct iovec *iov,
2015                  unsigned long nr_segs, loff_t *poffset)
2016 {
2017         unsigned int written;
2018         unsigned long num_pages, npages, i;
2019         size_t copied, len, cur_len;
2020         ssize_t total_written = 0;
2021         struct kvec *to_send;
2022         struct page **pages;
2023         struct iov_iter it;
2024         struct inode *inode;
2025         struct cifsFileInfo *open_file;
2026         struct cifs_tcon *pTcon;
2027         struct cifs_sb_info *cifs_sb;
2028         struct cifs_io_parms io_parms;
2029         int xid, rc;
2030         __u32 pid;
2031
2032         len = iov_length(iov, nr_segs);
2033         if (!len)
2034                 return 0;
2035
2036         rc = generic_write_checks(file, poffset, &len, 0);
2037         if (rc)
2038                 return rc;
2039
2040         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2041         num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2042
2043         pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2044         if (!pages)
2045                 return -ENOMEM;
2046
2047         to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2048         if (!to_send) {
2049                 kfree(pages);
2050                 return -ENOMEM;
2051         }
2052
2053         rc = cifs_write_allocate_pages(pages, num_pages);
2054         if (rc) {
2055                 kfree(pages);
2056                 kfree(to_send);
2057                 return rc;
2058         }
2059
2060         xid = GetXid();
2061         open_file = file->private_data;
2062
2063         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2064                 pid = open_file->pid;
2065         else
2066                 pid = current->tgid;
2067
2068         pTcon = tlink_tcon(open_file->tlink);
2069         inode = file->f_path.dentry->d_inode;
2070
2071         iov_iter_init(&it, iov, nr_segs, len, 0);
2072         npages = num_pages;
2073
2074         do {
2075                 size_t save_len = cur_len;
2076                 for (i = 0; i < npages; i++) {
2077                         copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2078                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
2079                                                          copied);
2080                         cur_len -= copied;
2081                         iov_iter_advance(&it, copied);
2082                         to_send[i+1].iov_base = kmap(pages[i]);
2083                         to_send[i+1].iov_len = copied;
2084                 }
2085
2086                 cur_len = save_len - cur_len;
2087
2088                 do {
2089                         if (open_file->invalidHandle) {
2090                                 rc = cifs_reopen_file(open_file, false);
2091                                 if (rc != 0)
2092                                         break;
2093                         }
2094                         io_parms.netfid = open_file->netfid;
2095                         io_parms.pid = pid;
2096                         io_parms.tcon = pTcon;
2097                         io_parms.offset = *poffset;
2098                         io_parms.length = cur_len;
2099                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2100                                            npages, 0);
2101                 } while (rc == -EAGAIN);
2102
2103                 for (i = 0; i < npages; i++)
2104                         kunmap(pages[i]);
2105
2106                 if (written) {
2107                         len -= written;
2108                         total_written += written;
2109                         cifs_update_eof(CIFS_I(inode), *poffset, written);
2110                         *poffset += written;
2111                 } else if (rc < 0) {
2112                         if (!total_written)
2113                                 total_written = rc;
2114                         break;
2115                 }
2116
2117                 /* get length and number of kvecs of the next write */
2118                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2119         } while (len > 0);
2120
2121         if (total_written > 0) {
2122                 spin_lock(&inode->i_lock);
2123                 if (*poffset > inode->i_size)
2124                         i_size_write(inode, *poffset);
2125                 spin_unlock(&inode->i_lock);
2126         }
2127
2128         cifs_stats_bytes_written(pTcon, total_written);
2129         mark_inode_dirty_sync(inode);
2130
2131         for (i = 0; i < num_pages; i++)
2132                 put_page(pages[i]);
2133         kfree(to_send);
2134         kfree(pages);
2135         FreeXid(xid);
2136         return total_written;
2137 }
2138
2139 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2140                                 unsigned long nr_segs, loff_t pos)
2141 {
2142         ssize_t written;
2143         struct inode *inode;
2144
2145         inode = iocb->ki_filp->f_path.dentry->d_inode;
2146
2147         /*
2148          * BB - optimize the way when signing is disabled. We can drop this
2149          * extra memory-to-memory copying and use iovec buffers for constructing
2150          * write request.
2151          */
2152
2153         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2154         if (written > 0) {
2155                 CIFS_I(inode)->invalid_mapping = true;
2156                 iocb->ki_pos = pos;
2157         }
2158
2159         return written;
2160 }
2161
2162 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2163                            unsigned long nr_segs, loff_t pos)
2164 {
2165         struct inode *inode;
2166
2167         inode = iocb->ki_filp->f_path.dentry->d_inode;
2168
2169         if (CIFS_I(inode)->clientCanCacheAll)
2170                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2171
2172         /*
2173          * In strict cache mode we need to write the data to the server exactly
2174          * from the pos to pos+len-1 rather than flush all affected pages
2175          * because it may cause a error with mandatory locks on these pages but
2176          * not on the region from pos to ppos+len-1.
2177          */
2178
2179         return cifs_user_writev(iocb, iov, nr_segs, pos);
2180 }
2181
2182 static ssize_t
2183 cifs_iovec_read(struct file *file, const struct iovec *iov,
2184                  unsigned long nr_segs, loff_t *poffset)
2185 {
2186         int rc;
2187         int xid;
2188         ssize_t total_read;
2189         unsigned int bytes_read = 0;
2190         size_t len, cur_len;
2191         int iov_offset = 0;
2192         struct cifs_sb_info *cifs_sb;
2193         struct cifs_tcon *pTcon;
2194         struct cifsFileInfo *open_file;
2195         struct smb_com_read_rsp *pSMBr;
2196         struct cifs_io_parms io_parms;
2197         char *read_data;
2198         unsigned int rsize;
2199         __u32 pid;
2200
2201         if (!nr_segs)
2202                 return 0;
2203
2204         len = iov_length(iov, nr_segs);
2205         if (!len)
2206                 return 0;
2207
2208         xid = GetXid();
2209         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2210
2211         /* FIXME: set up handlers for larger reads and/or convert to async */
2212         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2213
2214         open_file = file->private_data;
2215         pTcon = tlink_tcon(open_file->tlink);
2216
2217         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2218                 pid = open_file->pid;
2219         else
2220                 pid = current->tgid;
2221
2222         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2223                 cFYI(1, "attempting read on write only file instance");
2224
2225         for (total_read = 0; total_read < len; total_read += bytes_read) {
2226                 cur_len = min_t(const size_t, len - total_read, rsize);
2227                 rc = -EAGAIN;
2228                 read_data = NULL;
2229
2230                 while (rc == -EAGAIN) {
2231                         int buf_type = CIFS_NO_BUFFER;
2232                         if (open_file->invalidHandle) {
2233                                 rc = cifs_reopen_file(open_file, true);
2234                                 if (rc != 0)
2235                                         break;
2236                         }
2237                         io_parms.netfid = open_file->netfid;
2238                         io_parms.pid = pid;
2239                         io_parms.tcon = pTcon;
2240                         io_parms.offset = *poffset;
2241                         io_parms.length = cur_len;
2242                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2243                                          &read_data, &buf_type);
2244                         pSMBr = (struct smb_com_read_rsp *)read_data;
2245                         if (read_data) {
2246                                 char *data_offset = read_data + 4 +
2247                                                 le16_to_cpu(pSMBr->DataOffset);
2248                                 if (memcpy_toiovecend(iov, data_offset,
2249                                                       iov_offset, bytes_read))
2250                                         rc = -EFAULT;
2251                                 if (buf_type == CIFS_SMALL_BUFFER)
2252                                         cifs_small_buf_release(read_data);
2253                                 else if (buf_type == CIFS_LARGE_BUFFER)
2254                                         cifs_buf_release(read_data);
2255                                 read_data = NULL;
2256                                 iov_offset += bytes_read;
2257                         }
2258                 }
2259
2260                 if (rc || (bytes_read == 0)) {
2261                         if (total_read) {
2262                                 break;
2263                         } else {
2264                                 FreeXid(xid);
2265                                 return rc;
2266                         }
2267                 } else {
2268                         cifs_stats_bytes_read(pTcon, bytes_read);
2269                         *poffset += bytes_read;
2270                 }
2271         }
2272
2273         FreeXid(xid);
2274         return total_read;
2275 }
2276
2277 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2278                                unsigned long nr_segs, loff_t pos)
2279 {
2280         ssize_t read;
2281
2282         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2283         if (read > 0)
2284                 iocb->ki_pos = pos;
2285
2286         return read;
2287 }
2288
2289 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2290                           unsigned long nr_segs, loff_t pos)
2291 {
2292         struct inode *inode;
2293
2294         inode = iocb->ki_filp->f_path.dentry->d_inode;
2295
2296         if (CIFS_I(inode)->clientCanCacheRead)
2297                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2298
2299         /*
2300          * In strict cache mode we need to read from the server all the time
2301          * if we don't have level II oplock because the server can delay mtime
2302          * change - so we can't make a decision about inode invalidating.
2303          * And we can also fail with pagereading if there are mandatory locks
2304          * on pages affected by this read but not on the region from pos to
2305          * pos+len-1.
2306          */
2307
2308         return cifs_user_readv(iocb, iov, nr_segs, pos);
2309 }
2310
2311 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2312                          loff_t *poffset)
2313 {
2314         int rc = -EACCES;
2315         unsigned int bytes_read = 0;
2316         unsigned int total_read;
2317         unsigned int current_read_size;
2318         unsigned int rsize;
2319         struct cifs_sb_info *cifs_sb;
2320         struct cifs_tcon *pTcon;
2321         int xid;
2322         char *current_offset;
2323         struct cifsFileInfo *open_file;
2324         struct cifs_io_parms io_parms;
2325         int buf_type = CIFS_NO_BUFFER;
2326         __u32 pid;
2327
2328         xid = GetXid();
2329         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2330
2331         /* FIXME: set up handlers for larger reads and/or convert to async */
2332         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2333
2334         if (file->private_data == NULL) {
2335                 rc = -EBADF;
2336                 FreeXid(xid);
2337                 return rc;
2338         }
2339         open_file = file->private_data;
2340         pTcon = tlink_tcon(open_file->tlink);
2341
2342         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2343                 pid = open_file->pid;
2344         else
2345                 pid = current->tgid;
2346
2347         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2348                 cFYI(1, "attempting read on write only file instance");
2349
2350         for (total_read = 0, current_offset = read_data;
2351              read_size > total_read;
2352              total_read += bytes_read, current_offset += bytes_read) {
2353                 current_read_size = min_t(uint, read_size - total_read, rsize);
2354
2355                 /* For windows me and 9x we do not want to request more
2356                 than it negotiated since it will refuse the read then */
2357                 if ((pTcon->ses) &&
2358                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2359                         current_read_size = min_t(uint, current_read_size,
2360                                         CIFSMaxBufSize);
2361                 }
2362                 rc = -EAGAIN;
2363                 while (rc == -EAGAIN) {
2364                         if (open_file->invalidHandle) {
2365                                 rc = cifs_reopen_file(open_file, true);
2366                                 if (rc != 0)
2367                                         break;
2368                         }
2369                         io_parms.netfid = open_file->netfid;
2370                         io_parms.pid = pid;
2371                         io_parms.tcon = pTcon;
2372                         io_parms.offset = *poffset;
2373                         io_parms.length = current_read_size;
2374                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2375                                          &current_offset, &buf_type);
2376                 }
2377                 if (rc || (bytes_read == 0)) {
2378                         if (total_read) {
2379                                 break;
2380                         } else {
2381                                 FreeXid(xid);
2382                                 return rc;
2383                         }
2384                 } else {
2385                         cifs_stats_bytes_read(pTcon, total_read);
2386                         *poffset += bytes_read;
2387                 }
2388         }
2389         FreeXid(xid);
2390         return total_read;
2391 }
2392
2393 /*
2394  * If the page is mmap'ed into a process' page tables, then we need to make
2395  * sure that it doesn't change while being written back.
2396  */
2397 static int
2398 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2399 {
2400         struct page *page = vmf->page;
2401
2402         lock_page(page);
2403         return VM_FAULT_LOCKED;
2404 }
2405
2406 static struct vm_operations_struct cifs_file_vm_ops = {
2407         .fault = filemap_fault,
2408         .page_mkwrite = cifs_page_mkwrite,
2409 };
2410
2411 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2412 {
2413         int rc, xid;
2414         struct inode *inode = file->f_path.dentry->d_inode;
2415
2416         xid = GetXid();
2417
2418         if (!CIFS_I(inode)->clientCanCacheRead) {
2419                 rc = cifs_invalidate_mapping(inode);
2420                 if (rc)
2421                         return rc;
2422         }
2423
2424         rc = generic_file_mmap(file, vma);
2425         if (rc == 0)
2426                 vma->vm_ops = &cifs_file_vm_ops;
2427         FreeXid(xid);
2428         return rc;
2429 }
2430
2431 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2432 {
2433         int rc, xid;
2434
2435         xid = GetXid();
2436         rc = cifs_revalidate_file(file);
2437         if (rc) {
2438                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2439                 FreeXid(xid);
2440                 return rc;
2441         }
2442         rc = generic_file_mmap(file, vma);
2443         if (rc == 0)
2444                 vma->vm_ops = &cifs_file_vm_ops;
2445         FreeXid(xid);
2446         return rc;
2447 }
2448
2449 static int cifs_readpages(struct file *file, struct address_space *mapping,
2450         struct list_head *page_list, unsigned num_pages)
2451 {
2452         int rc;
2453         struct list_head tmplist;
2454         struct cifsFileInfo *open_file = file->private_data;
2455         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2456         unsigned int rsize = cifs_sb->rsize;
2457         pid_t pid;
2458
2459         /*
2460          * Give up immediately if rsize is too small to read an entire page.
2461          * The VFS will fall back to readpage. We should never reach this
2462          * point however since we set ra_pages to 0 when the rsize is smaller
2463          * than a cache page.
2464          */
2465         if (unlikely(rsize < PAGE_CACHE_SIZE))
2466                 return 0;
2467
2468         /*
2469          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2470          * immediately if the cookie is negative
2471          */
2472         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2473                                          &num_pages);
2474         if (rc == 0)
2475                 return rc;
2476
2477         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2478                 pid = open_file->pid;
2479         else
2480                 pid = current->tgid;
2481
2482         rc = 0;
2483         INIT_LIST_HEAD(&tmplist);
2484
2485         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2486                 mapping, num_pages);
2487
2488         /*
2489          * Start with the page at end of list and move it to private
2490          * list. Do the same with any following pages until we hit
2491          * the rsize limit, hit an index discontinuity, or run out of
2492          * pages. Issue the async read and then start the loop again
2493          * until the list is empty.
2494          *
2495          * Note that list order is important. The page_list is in
2496          * the order of declining indexes. When we put the pages in
2497          * the rdata->pages, then we want them in increasing order.
2498          */
2499         while (!list_empty(page_list)) {
2500                 unsigned int bytes = PAGE_CACHE_SIZE;
2501                 unsigned int expected_index;
2502                 unsigned int nr_pages = 1;
2503                 loff_t offset;
2504                 struct page *page, *tpage;
2505                 struct cifs_readdata *rdata;
2506
2507                 page = list_entry(page_list->prev, struct page, lru);
2508
2509                 /*
2510                  * Lock the page and put it in the cache. Since no one else
2511                  * should have access to this page, we're safe to simply set
2512                  * PG_locked without checking it first.
2513                  */
2514                 __set_page_locked(page);
2515                 rc = add_to_page_cache_locked(page, mapping,
2516                                               page->index, GFP_KERNEL);
2517
2518                 /* give up if we can't stick it in the cache */
2519                 if (rc) {
2520                         __clear_page_locked(page);
2521                         break;
2522                 }
2523
2524                 /* move first page to the tmplist */
2525                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2526                 list_move_tail(&page->lru, &tmplist);
2527
2528                 /* now try and add more pages onto the request */
2529                 expected_index = page->index + 1;
2530                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2531                         /* discontinuity ? */
2532                         if (page->index != expected_index)
2533                                 break;
2534
2535                         /* would this page push the read over the rsize? */
2536                         if (bytes + PAGE_CACHE_SIZE > rsize)
2537                                 break;
2538
2539                         __set_page_locked(page);
2540                         if (add_to_page_cache_locked(page, mapping,
2541                                                 page->index, GFP_KERNEL)) {
2542                                 __clear_page_locked(page);
2543                                 break;
2544                         }
2545                         list_move_tail(&page->lru, &tmplist);
2546                         bytes += PAGE_CACHE_SIZE;
2547                         expected_index++;
2548                         nr_pages++;
2549                 }
2550
2551                 rdata = cifs_readdata_alloc(nr_pages);
2552                 if (!rdata) {
2553                         /* best to give up if we're out of mem */
2554                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2555                                 list_del(&page->lru);
2556                                 lru_cache_add_file(page);
2557                                 unlock_page(page);
2558                                 page_cache_release(page);
2559                         }
2560                         rc = -ENOMEM;
2561                         break;
2562                 }
2563
2564                 spin_lock(&cifs_file_list_lock);
2565                 cifsFileInfo_get(open_file);
2566                 spin_unlock(&cifs_file_list_lock);
2567                 rdata->cfile = open_file;
2568                 rdata->mapping = mapping;
2569                 rdata->offset = offset;
2570                 rdata->bytes = bytes;
2571                 rdata->pid = pid;
2572                 list_splice_init(&tmplist, &rdata->pages);
2573
2574                 do {
2575                         if (open_file->invalidHandle) {
2576                                 rc = cifs_reopen_file(open_file, true);
2577                                 if (rc != 0)
2578                                         continue;
2579                         }
2580                         rc = cifs_async_readv(rdata);
2581                 } while (rc == -EAGAIN);
2582
2583                 if (rc != 0) {
2584                         list_for_each_entry_safe(page, tpage, &rdata->pages,
2585                                                  lru) {
2586                                 list_del(&page->lru);
2587                                 lru_cache_add_file(page);
2588                                 unlock_page(page);
2589                                 page_cache_release(page);
2590                         }
2591                         cifs_readdata_free(rdata);
2592                         break;
2593                 }
2594         }
2595
2596         return rc;
2597 }
2598
2599 static int cifs_readpage_worker(struct file *file, struct page *page,
2600         loff_t *poffset)
2601 {
2602         char *read_data;
2603         int rc;
2604
2605         /* Is the page cached? */
2606         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2607         if (rc == 0)
2608                 goto read_complete;
2609
2610         page_cache_get(page);
2611         read_data = kmap(page);
2612         /* for reads over a certain size could initiate async read ahead */
2613
2614         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2615
2616         if (rc < 0)
2617                 goto io_error;
2618         else
2619                 cFYI(1, "Bytes read %d", rc);
2620
2621         file->f_path.dentry->d_inode->i_atime =
2622                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2623
2624         if (PAGE_CACHE_SIZE > rc)
2625                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2626
2627         flush_dcache_page(page);
2628         SetPageUptodate(page);
2629
2630         /* send this page to the cache */
2631         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2632
2633         rc = 0;
2634
2635 io_error:
2636         kunmap(page);
2637         page_cache_release(page);
2638
2639 read_complete:
2640         return rc;
2641 }
2642
2643 static int cifs_readpage(struct file *file, struct page *page)
2644 {
2645         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2646         int rc = -EACCES;
2647         int xid;
2648
2649         xid = GetXid();
2650
2651         if (file->private_data == NULL) {
2652                 rc = -EBADF;
2653                 FreeXid(xid);
2654                 return rc;
2655         }
2656
2657         cFYI(1, "readpage %p at offset %d 0x%x\n",
2658                  page, (int)offset, (int)offset);
2659
2660         rc = cifs_readpage_worker(file, page, &offset);
2661
2662         unlock_page(page);
2663
2664         FreeXid(xid);
2665         return rc;
2666 }
2667
2668 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2669 {
2670         struct cifsFileInfo *open_file;
2671
2672         spin_lock(&cifs_file_list_lock);
2673         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2674                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2675                         spin_unlock(&cifs_file_list_lock);
2676                         return 1;
2677                 }
2678         }
2679         spin_unlock(&cifs_file_list_lock);
2680         return 0;
2681 }
2682
2683 /* We do not want to update the file size from server for inodes
2684    open for write - to avoid races with writepage extending
2685    the file - in the future we could consider allowing
2686    refreshing the inode only on increases in the file size
2687    but this is tricky to do without racing with writebehind
2688    page caching in the current Linux kernel design */
2689 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2690 {
2691         if (!cifsInode)
2692                 return true;
2693
2694         if (is_inode_writable(cifsInode)) {
2695                 /* This inode is open for write at least once */
2696                 struct cifs_sb_info *cifs_sb;
2697
2698                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2699                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2700                         /* since no page cache to corrupt on directio
2701                         we can change size safely */
2702                         return true;
2703                 }
2704
2705                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2706                         return true;
2707
2708                 return false;
2709         } else
2710                 return true;
2711 }
2712
2713 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2714                         loff_t pos, unsigned len, unsigned flags,
2715                         struct page **pagep, void **fsdata)
2716 {
2717         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2718         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2719         loff_t page_start = pos & PAGE_MASK;
2720         loff_t i_size;
2721         struct page *page;
2722         int rc = 0;
2723
2724         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2725
2726         page = grab_cache_page_write_begin(mapping, index, flags);
2727         if (!page) {
2728                 rc = -ENOMEM;
2729                 goto out;
2730         }
2731
2732         if (PageUptodate(page))
2733                 goto out;
2734
2735         /*
2736          * If we write a full page it will be up to date, no need to read from
2737          * the server. If the write is short, we'll end up doing a sync write
2738          * instead.
2739          */
2740         if (len == PAGE_CACHE_SIZE)
2741                 goto out;
2742
2743         /*
2744          * optimize away the read when we have an oplock, and we're not
2745          * expecting to use any of the data we'd be reading in. That
2746          * is, when the page lies beyond the EOF, or straddles the EOF
2747          * and the write will cover all of the existing data.
2748          */
2749         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2750                 i_size = i_size_read(mapping->host);
2751                 if (page_start >= i_size ||
2752                     (offset == 0 && (pos + len) >= i_size)) {
2753                         zero_user_segments(page, 0, offset,
2754                                            offset + len,
2755                                            PAGE_CACHE_SIZE);
2756                         /*
2757                          * PageChecked means that the parts of the page
2758                          * to which we're not writing are considered up
2759                          * to date. Once the data is copied to the
2760                          * page, it can be set uptodate.
2761                          */
2762                         SetPageChecked(page);
2763                         goto out;
2764                 }
2765         }
2766
2767         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2768                 /*
2769                  * might as well read a page, it is fast enough. If we get
2770                  * an error, we don't need to return it. cifs_write_end will
2771                  * do a sync write instead since PG_uptodate isn't set.
2772                  */
2773                 cifs_readpage_worker(file, page, &page_start);
2774         } else {
2775                 /* we could try using another file handle if there is one -
2776                    but how would we lock it to prevent close of that handle
2777                    racing with this read? In any case
2778                    this will be written out by write_end so is fine */
2779         }
2780 out:
2781         *pagep = page;
2782         return rc;
2783 }
2784
2785 static int cifs_release_page(struct page *page, gfp_t gfp)
2786 {
2787         if (PagePrivate(page))
2788                 return 0;
2789
2790         return cifs_fscache_release_page(page, gfp);
2791 }
2792
2793 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2794 {
2795         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2796
2797         if (offset == 0)
2798                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2799 }
2800
2801 static int cifs_launder_page(struct page *page)
2802 {
2803         int rc = 0;
2804         loff_t range_start = page_offset(page);
2805         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2806         struct writeback_control wbc = {
2807                 .sync_mode = WB_SYNC_ALL,
2808                 .nr_to_write = 0,
2809                 .range_start = range_start,
2810                 .range_end = range_end,
2811         };
2812
2813         cFYI(1, "Launder page: %p", page);
2814
2815         if (clear_page_dirty_for_io(page))
2816                 rc = cifs_writepage_locked(page, &wbc);
2817
2818         cifs_fscache_invalidate_page(page, page->mapping->host);
2819         return rc;
2820 }
2821
2822 void cifs_oplock_break(struct work_struct *work)
2823 {
2824         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2825                                                   oplock_break);
2826         struct inode *inode = cfile->dentry->d_inode;
2827         struct cifsInodeInfo *cinode = CIFS_I(inode);
2828         int rc = 0;
2829
2830         if (inode && S_ISREG(inode->i_mode)) {
2831                 if (cinode->clientCanCacheRead)
2832                         break_lease(inode, O_RDONLY);
2833                 else
2834                         break_lease(inode, O_WRONLY);
2835                 rc = filemap_fdatawrite(inode->i_mapping);
2836                 if (cinode->clientCanCacheRead == 0) {
2837                         rc = filemap_fdatawait(inode->i_mapping);
2838                         mapping_set_error(inode->i_mapping, rc);
2839                         invalidate_remote_inode(inode);
2840                 }
2841                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2842         }
2843
2844         rc = cifs_push_locks(cfile);
2845         if (rc)
2846                 cERROR(1, "Push locks rc = %d", rc);
2847
2848         /*
2849          * releasing stale oplock after recent reconnect of smb session using
2850          * a now incorrect file handle is not a data integrity issue but do
2851          * not bother sending an oplock release if session to server still is
2852          * disconnected since oplock already released by the server
2853          */
2854         if (!cfile->oplock_break_cancelled) {
2855                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2856                                  current->tgid, 0, 0, 0, 0,
2857                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
2858                                  cinode->clientCanCacheRead ? 1 : 0);
2859                 cFYI(1, "Oplock release rc = %d", rc);
2860         }
2861 }
2862
2863 const struct address_space_operations cifs_addr_ops = {
2864         .readpage = cifs_readpage,
2865         .readpages = cifs_readpages,
2866         .writepage = cifs_writepage,
2867         .writepages = cifs_writepages,
2868         .write_begin = cifs_write_begin,
2869         .write_end = cifs_write_end,
2870         .set_page_dirty = __set_page_dirty_nobuffers,
2871         .releasepage = cifs_release_page,
2872         .invalidatepage = cifs_invalidate_page,
2873         .launder_page = cifs_launder_page,
2874 };
2875
2876 /*
2877  * cifs_readpages requires the server to support a buffer large enough to
2878  * contain the header plus one complete page of data.  Otherwise, we need
2879  * to leave cifs_readpages out of the address space operations.
2880  */
2881 const struct address_space_operations cifs_addr_ops_smallbuf = {
2882         .readpage = cifs_readpage,
2883         .writepage = cifs_writepage,
2884         .writepages = cifs_writepages,
2885         .write_begin = cifs_write_begin,
2886         .write_end = cifs_write_end,
2887         .set_page_dirty = __set_page_dirty_nobuffers,
2888         .releasepage = cifs_release_page,
2889         .invalidatepage = cifs_invalidate_page,
2890         .launder_page = cifs_launder_page,
2891 };