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 /*
 706  * Check if there is another lock that prevents us to set the lock (mandatory
 707  * style). If such a lock exists, update the flock structure with its
 708  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 709  * or leave it the same if we can't. Returns 0 if we don't need to request to
 710  * the server or 1 otherwise.
 711  */
 712 static int
 713 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
 714                __u8 type, __u16 netfid, struct file_lock *flock)
 715 {
 716         int rc = 0;
 717         struct cifsLockInfo *conf_lock;
 718         bool exist;
 719
 720         mutex_lock(&cinode->lock_mutex);
 721
 722         exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
 723                                           &conf_lock);
 724         if (exist) {
 725                 flock->fl_start = conf_lock->offset;
 726                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
 727                 flock->fl_pid = conf_lock->pid;
 728                 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
 729                         flock->fl_type = F_RDLCK;
 730                 else
 731                         flock->fl_type = F_WRLCK;
 732         } else if (!cinode->can_cache_brlcks)
 733                 rc = 1;
 734         else
 735                 flock->fl_type = F_UNLCK;
 736
 737         mutex_unlock(&cinode->lock_mutex);
 738         return rc;
 739 }
 740
 741 static void
 742 cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
 743 {
 744         mutex_lock(&cinode->lock_mutex);
 745         list_add_tail(&lock->llist, &cinode->llist);
 746         mutex_unlock(&cinode->lock_mutex);
 747 }
 748
 749 /*
 750  * Set the byte-range lock (mandatory style). Returns:
 751  * 1) 0, if we set the lock and don't need to request to the server;
 752  * 2) 1, if no locks prevent us but we need to request to the server;
 753  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
 754  */
 755 static int
 756 cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
 757                  bool wait)
 758 {
 759         struct cifsLockInfo *conf_lock;
 760         bool exist;
 761         int rc = 0;
 762
 763 try_again:
 764         exist = false;
 765         mutex_lock(&cinode->lock_mutex);
 766
 767         exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
 768         if (!exist && cinode->can_cache_brlcks) {
 769                 list_add_tail(&lock->llist, &cinode->llist);
 770                 mutex_unlock(&cinode->lock_mutex);
 771                 return rc;
 772         }
 773
 774         if (!exist)
 775                 rc = 1;
 776         else if (!wait)
 777                 rc = -EACCES;
 778         else {
 779                 list_add_tail(&lock->blist, &conf_lock->blist);
 780                 mutex_unlock(&cinode->lock_mutex);
 781                 rc = wait_event_interruptible(lock->block_q,
 782                                         (lock->blist.prev == &lock->blist) &&
 783                                         (lock->blist.next == &lock->blist));
 784                 if (!rc)
 785                         goto try_again;
 786                 mutex_lock(&cinode->lock_mutex);
 787                 list_del_init(&lock->blist);
 788         }
 789
 790         mutex_unlock(&cinode->lock_mutex);
 791         return rc;
 792 }
 793
 794 /*
 795  * Check if there is another lock that prevents us to set the lock (posix
 796  * style). If such a lock exists, update the flock structure with its
 797  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 798  * or leave it the same if we can't. Returns 0 if we don't need to request to
 799  * the server or 1 otherwise.
 800  */
 801 static int
 802 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 803 {
 804         int rc = 0;
 805         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 806         unsigned char saved_type = flock->fl_type;
 807
 808         if ((flock->fl_flags & FL_POSIX) == 0)
 809                 return 1;
 810
 811         mutex_lock(&cinode->lock_mutex);
 812         posix_test_lock(file, flock);
 813
 814         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
 815                 flock->fl_type = saved_type;
 816                 rc = 1;
 817         }
 818
 819         mutex_unlock(&cinode->lock_mutex);
 820         return rc;
 821 }
 822
 823 /*
 824  * Set the byte-range lock (posix style). Returns:
 825  * 1) 0, if we set the lock and don't need to request to the server;
 826  * 2) 1, if we need to request to the server;
 827  * 3) <0, if the error occurs while setting the lock.
 828  */
 829 static int
 830 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
 831 {
 832         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 833         int rc = 1;
 834
 835         if ((flock->fl_flags & FL_POSIX) == 0)
 836                 return rc;
 837
 838         mutex_lock(&cinode->lock_mutex);
 839         if (!cinode->can_cache_brlcks) {
 840                 mutex_unlock(&cinode->lock_mutex);
 841                 return rc;
 842         }
 843         rc = posix_lock_file_wait(file, flock);
 844         mutex_unlock(&cinode->lock_mutex);
 845         return rc;
 846 }
 847
 848 static int
 849 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
 850 {
 851         int xid, rc = 0, stored_rc;
 852         struct cifsLockInfo *li, *tmp;
 853         struct cifs_tcon *tcon;
 854         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 855         unsigned int num, max_num;
 856         LOCKING_ANDX_RANGE *buf, *cur;
 857         int types[] = {LOCKING_ANDX_LARGE_FILES,
 858                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
 859         int i;
 860
 861         xid = GetXid();
 862         tcon = tlink_tcon(cfile->tlink);
 863
 864         mutex_lock(&cinode->lock_mutex);
 865         if (!cinode->can_cache_brlcks) {
 866                 mutex_unlock(&cinode->lock_mutex);
 867                 FreeXid(xid);
 868                 return rc;
 869         }
 870
 871         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
 872                   sizeof(LOCKING_ANDX_RANGE);
 873         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
 874         if (!buf) {
 875                 mutex_unlock(&cinode->lock_mutex);
 876                 FreeXid(xid);
 877                 return rc;
 878         }
 879
 880         for (i = 0; i < 2; i++) {
 881                 cur = buf;
 882                 num = 0;
 883                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
 884                         if (li->type != types[i])
 885                                 continue;
 886                         cur->Pid = cpu_to_le16(li->pid);
 887                         cur->LengthLow = cpu_to_le32((u32)li->length);
 888                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
 889                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
 890                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
 891                         if (++num == max_num) {
 892                                 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 893                                                        li->type, 0, num, buf);
 894                                 if (stored_rc)
 895                                         rc = stored_rc;
 896                                 cur = buf;
 897                                 num = 0;
 898                         } else
 899                                 cur++;
 900                 }
 901
 902                 if (num) {
 903                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 904                                                types[i], 0, num, buf);
 905                         if (stored_rc)
 906                                 rc = stored_rc;
 907                 }
 908         }
 909
 910         cinode->can_cache_brlcks = false;
 911         mutex_unlock(&cinode->lock_mutex);
 912
 913         kfree(buf);
 914         FreeXid(xid);
 915         return rc;
 916 }
 917
 918 /* copied from fs/locks.c with a name change */
 919 #define cifs_for_each_lock(inode, lockp) \
 920         for (lockp = &inode->i_flock; *lockp != NULL; \
 921              lockp = &(*lockp)->fl_next)
 922
 923 static int
 924 cifs_push_posix_locks(struct cifsFileInfo *cfile)
 925 {
 926         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 927         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 928         struct file_lock *flock, **before;
 929         struct cifsLockInfo *lck, *tmp;
 930         int rc = 0, xid, type;
 931         __u64 length;
 932         struct list_head locks_to_send;
 933
 934         xid = GetXid();
 935
 936         mutex_lock(&cinode->lock_mutex);
 937         if (!cinode->can_cache_brlcks) {
 938                 mutex_unlock(&cinode->lock_mutex);
 939                 FreeXid(xid);
 940                 return rc;
 941         }
 942
 943         INIT_LIST_HEAD(&locks_to_send);
 944
 945         lock_flocks();
 946         cifs_for_each_lock(cfile->dentry->d_inode, before) {
 947                 flock = *before;
 948                 length = 1 + flock->fl_end - flock->fl_start;
 949                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
 950                         type = CIFS_RDLCK;
 951                 else
 952                         type = CIFS_WRLCK;
 953
 954                 lck = cifs_lock_init(flock->fl_start, length, type,
 955                                      cfile->netfid);
 956                 if (!lck) {
 957                         rc = -ENOMEM;
 958                         goto send_locks;
 959                 }
 960                 lck->pid = flock->fl_pid;
 961
 962                 list_add_tail(&lck->llist, &locks_to_send);
 963         }
 964
 965 send_locks:
 966         unlock_flocks();
 967
 968         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
 969                 struct file_lock tmp_lock;
 970                 int stored_rc;
 971
 972                 tmp_lock.fl_start = lck->offset;
 973                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
 974                                              0, lck->length, &tmp_lock,
 975                                              lck->type, 0);
 976                 if (stored_rc)
 977                         rc = stored_rc;
 978                 list_del(&lck->llist);
 979                 kfree(lck);
 980         }
 981
 982         cinode->can_cache_brlcks = false;
 983         mutex_unlock(&cinode->lock_mutex);
 984
 985         FreeXid(xid);
 986         return rc;
 987 }
 988
 989 static int
 990 cifs_push_locks(struct cifsFileInfo *cfile)
 991 {
 992         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
 993         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 994
 995         if ((tcon->ses->capabilities & CAP_UNIX) &&
 996             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 997             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 998                 return cifs_push_posix_locks(cfile);
 999
1000         return cifs_push_mandatory_locks(cfile);
1001 }
1002
1003 static void
1004 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1005                 bool *wait_flag)
1006 {
1007         if (flock->fl_flags & FL_POSIX)
1008                 cFYI(1, "Posix");
1009         if (flock->fl_flags & FL_FLOCK)
1010                 cFYI(1, "Flock");
1011         if (flock->fl_flags & FL_SLEEP) {
1012                 cFYI(1, "Blocking lock");
1013                 *wait_flag = true;
1014         }
1015         if (flock->fl_flags & FL_ACCESS)
1016                 cFYI(1, "Process suspended by mandatory locking - "
1017                         "not implemented yet");
1018         if (flock->fl_flags & FL_LEASE)
1019                 cFYI(1, "Lease on file - not implemented yet");
1020         if (flock->fl_flags &
1021             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1022                 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1023
1024         *type = LOCKING_ANDX_LARGE_FILES;
1025         if (flock->fl_type == F_WRLCK) {
1026                 cFYI(1, "F_WRLCK ");
1027                 *lock = 1;
1028         } else if (flock->fl_type == F_UNLCK) {
1029                 cFYI(1, "F_UNLCK");
1030                 *unlock = 1;
1031                 /* Check if unlock includes more than one lock range */
1032         } else if (flock->fl_type == F_RDLCK) {
1033                 cFYI(1, "F_RDLCK");
1034                 *type |= LOCKING_ANDX_SHARED_LOCK;
1035                 *lock = 1;
1036         } else if (flock->fl_type == F_EXLCK) {
1037                 cFYI(1, "F_EXLCK");
1038                 *lock = 1;
1039         } else if (flock->fl_type == F_SHLCK) {
1040                 cFYI(1, "F_SHLCK");
1041                 *type |= LOCKING_ANDX_SHARED_LOCK;
1042                 *lock = 1;
1043         } else
1044                 cFYI(1, "Unknown type of lock");
1045 }
1046
1047 static int
1048 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1049            bool wait_flag, bool posix_lck, int xid)
1050 {
1051         int rc = 0;
1052         __u64 length = 1 + flock->fl_end - flock->fl_start;
1053         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1054         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1055         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1056         __u16 netfid = cfile->netfid;
1057
1058         if (posix_lck) {
1059                 int posix_lock_type;
1060
1061                 rc = cifs_posix_lock_test(file, flock);
1062                 if (!rc)
1063                         return rc;
1064
1065                 if (type & LOCKING_ANDX_SHARED_LOCK)
1066                         posix_lock_type = CIFS_RDLCK;
1067                 else
1068                         posix_lock_type = CIFS_WRLCK;
1069                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1070                                       1 /* get */, length, flock,
1071                                       posix_lock_type, wait_flag);
1072                 return rc;
1073         }
1074
1075         rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1076                             flock);
1077         if (!rc)
1078                 return rc;
1079
1080         /* BB we could chain these into one lock request BB */
1081         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1082                          flock->fl_start, 0, 1, type, 0, 0);
1083         if (rc == 0) {
1084                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1085                                  length, flock->fl_start, 1, 0,
1086                                  type, 0, 0);
1087                 flock->fl_type = F_UNLCK;
1088                 if (rc != 0)
1089                         cERROR(1, "Error unlocking previously locked "
1090                                    "range %d during test of lock", rc);
1091                 return 0;
1092         }
1093
1094         if (type & LOCKING_ANDX_SHARED_LOCK) {
1095                 flock->fl_type = F_WRLCK;
1096                 return 0;
1097         }
1098
1099         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1100                          flock->fl_start, 0, 1,
1101                          type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1102         if (rc == 0) {
1103                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1104                                  length, flock->fl_start, 1, 0,
1105                                  type | LOCKING_ANDX_SHARED_LOCK,
1106                                  0, 0);
1107                 flock->fl_type = F_RDLCK;
1108                 if (rc != 0)
1109                         cERROR(1, "Error unlocking previously locked "
1110                                   "range %d during test of lock", rc);
1111         } else
1112                 flock->fl_type = F_WRLCK;
1113
1114         return 0;
1115 }
1116
1117 static void
1118 cifs_move_llist(struct list_head *source, struct list_head *dest)
1119 {
1120         struct list_head *li, *tmp;
1121         list_for_each_safe(li, tmp, source)
1122                 list_move(li, dest);
1123 }
1124
1125 static void
1126 cifs_free_llist(struct list_head *llist)
1127 {
1128         struct cifsLockInfo *li, *tmp;
1129         list_for_each_entry_safe(li, tmp, llist, llist) {
1130                 cifs_del_lock_waiters(li);
1131                 list_del(&li->llist);
1132                 kfree(li);
1133         }
1134 }
1135
1136 static int
1137 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1138 {
1139         int rc = 0, stored_rc;
1140         int types[] = {LOCKING_ANDX_LARGE_FILES,
1141                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1142         unsigned int i;
1143         unsigned int max_num, num;
1144         LOCKING_ANDX_RANGE *buf, *cur;
1145         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1146         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1147         struct cifsLockInfo *li, *tmp;
1148         __u64 length = 1 + flock->fl_end - flock->fl_start;
1149         struct list_head tmp_llist;
1150
1151         INIT_LIST_HEAD(&tmp_llist);
1152
1153         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1154                   sizeof(LOCKING_ANDX_RANGE);
1155         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1156         if (!buf)
1157                 return -ENOMEM;
1158
1159         mutex_lock(&cinode->lock_mutex);
1160         for (i = 0; i < 2; i++) {
1161                 cur = buf;
1162                 num = 0;
1163                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1164                         if (flock->fl_start > li->offset ||
1165                             (flock->fl_start + length) <
1166                             (li->offset + li->length))
1167                                 continue;
1168                         if (current->tgid != li->pid)
1169                                 continue;
1170                         if (cfile->netfid != li->netfid)
1171                                 continue;
1172                         if (types[i] != li->type)
1173                                 continue;
1174                         if (!cinode->can_cache_brlcks) {
1175                                 cur->Pid = cpu_to_le16(li->pid);
1176                                 cur->LengthLow = cpu_to_le32((u32)li->length);
1177                                 cur->LengthHigh =
1178                                         cpu_to_le32((u32)(li->length>>32));
1179                                 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1180                                 cur->OffsetHigh =
1181                                         cpu_to_le32((u32)(li->offset>>32));
1182                                 /*
1183                                  * We need to save a lock here to let us add
1184                                  * it again to the inode list if the unlock
1185                                  * range request fails on the server.
1186                                  */
1187                                 list_move(&li->llist, &tmp_llist);
1188                                 if (++num == max_num) {
1189                                         stored_rc = cifs_lockv(xid, tcon,
1190                                                                cfile->netfid,
1191                                                                li->type, num,
1192                                                                0, buf);
1193                                         if (stored_rc) {
1194                                                 /*
1195                                                  * We failed on the unlock range
1196                                                  * request - add all locks from
1197                                                  * the tmp list to the head of
1198                                                  * the inode list.
1199                                                  */
1200                                                 cifs_move_llist(&tmp_llist,
1201                                                                 &cinode->llist);
1202                                                 rc = stored_rc;
1203                                         } else
1204                                                 /*
1205                                                  * The unlock range request
1206                                                  * succeed - free the tmp list.
1207                                                  */
1208                                                 cifs_free_llist(&tmp_llist);
1209                                         cur = buf;
1210                                         num = 0;
1211                                 } else
1212                                         cur++;
1213                         } else {
1214                                 /*
1215                                  * We can cache brlock requests - simply remove
1216                                  * a lock from the inode list.
1217                                  */
1218                                 list_del(&li->llist);
1219                                 cifs_del_lock_waiters(li);
1220                                 kfree(li);
1221                         }
1222                 }
1223                 if (num) {
1224                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1225                                                types[i], num, 0, buf);
1226                         if (stored_rc) {
1227                                 cifs_move_llist(&tmp_llist, &cinode->llist);
1228                                 rc = stored_rc;
1229                         } else
1230                                 cifs_free_llist(&tmp_llist);
1231                 }
1232         }
1233
1234         mutex_unlock(&cinode->lock_mutex);
1235         kfree(buf);
1236         return rc;
1237 }
1238
1239 static int
1240 cifs_setlk(struct file *file,  struct file_lock *flock, __u8 type,
1241            bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1242 {
1243         int rc = 0;
1244         __u64 length = 1 + flock->fl_end - flock->fl_start;
1245         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1246         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1247         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1248         __u16 netfid = cfile->netfid;
1249
1250         if (posix_lck) {
1251                 int posix_lock_type;
1252
1253                 rc = cifs_posix_lock_set(file, flock);
1254                 if (!rc || rc < 0)
1255                         return rc;
1256
1257                 if (type & LOCKING_ANDX_SHARED_LOCK)
1258                         posix_lock_type = CIFS_RDLCK;
1259                 else
1260                         posix_lock_type = CIFS_WRLCK;
1261
1262                 if (unlock == 1)
1263                         posix_lock_type = CIFS_UNLCK;
1264
1265                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1266                                       0 /* set */, length, flock,
1267                                       posix_lock_type, wait_flag);
1268                 goto out;
1269         }
1270
1271         if (lock) {
1272                 struct cifsLockInfo *lock;
1273
1274                 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1275                 if (!lock)
1276                         return -ENOMEM;
1277
1278                 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1279                 if (rc < 0)
1280                         kfree(lock);
1281                 if (rc <= 0)
1282                         goto out;
1283
1284                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1285                                  flock->fl_start, 0, 1, type, wait_flag, 0);
1286                 if (rc) {
1287                         kfree(lock);
1288                         goto out;
1289                 }
1290
1291                 cifs_lock_add(cinode, lock);
1292         } else if (unlock)
1293                 rc = cifs_unlock_range(cfile, flock, xid);
1294
1295 out:
1296         if (flock->fl_flags & FL_POSIX)
1297                 posix_lock_file_wait(file, flock);
1298         return rc;
1299 }
1300
1301 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1302 {
1303         int rc, xid;
1304         int lock = 0, unlock = 0;
1305         bool wait_flag = false;
1306         bool posix_lck = false;
1307         struct cifs_sb_info *cifs_sb;
1308         struct cifs_tcon *tcon;
1309         struct cifsInodeInfo *cinode;
1310         struct cifsFileInfo *cfile;
1311         __u16 netfid;
1312         __u8 type;
1313
1314         rc = -EACCES;
1315         xid = GetXid();
1316
1317         cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1318                 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1319                 flock->fl_start, flock->fl_end);
1320
1321         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1322
1323         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1324         cfile = (struct cifsFileInfo *)file->private_data;
1325         tcon = tlink_tcon(cfile->tlink);
1326         netfid = cfile->netfid;
1327         cinode = CIFS_I(file->f_path.dentry->d_inode);
1328
1329         if ((tcon->ses->capabilities & CAP_UNIX) &&
1330             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1331             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1332                 posix_lck = true;
1333         /*
1334          * BB add code here to normalize offset and length to account for
1335          * negative length which we can not accept over the wire.
1336          */
1337         if (IS_GETLK(cmd)) {
1338                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1339                 FreeXid(xid);
1340                 return rc;
1341         }
1342
1343         if (!lock && !unlock) {
1344                 /*
1345                  * if no lock or unlock then nothing to do since we do not
1346                  * know what it is
1347                  */
1348                 FreeXid(xid);
1349                 return -EOPNOTSUPP;
1350         }
1351
1352         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1353                         xid);
1354         FreeXid(xid);
1355         return rc;
1356 }
1357
1358 /* update the file size (if needed) after a write */
1359 void
1360 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1361                       unsigned int bytes_written)
1362 {
1363         loff_t end_of_write = offset + bytes_written;
1364
1365         if (end_of_write > cifsi->server_eof)
1366                 cifsi->server_eof = end_of_write;
1367 }
1368
1369 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1370                           const char *write_data, size_t write_size,
1371                           loff_t *poffset)
1372 {
1373         int rc = 0;
1374         unsigned int bytes_written = 0;
1375         unsigned int total_written;
1376         struct cifs_sb_info *cifs_sb;
1377         struct cifs_tcon *pTcon;
1378         int xid;
1379         struct dentry *dentry = open_file->dentry;
1380         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1381         struct cifs_io_parms io_parms;
1382
1383         cifs_sb = CIFS_SB(dentry->d_sb);
1384
1385         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1386            *poffset, dentry->d_name.name);
1387
1388         pTcon = tlink_tcon(open_file->tlink);
1389
1390         xid = GetXid();
1391
1392         for (total_written = 0; write_size > total_written;
1393              total_written += bytes_written) {
1394                 rc = -EAGAIN;
1395                 while (rc == -EAGAIN) {
1396                         struct kvec iov[2];
1397                         unsigned int len;
1398
1399                         if (open_file->invalidHandle) {
1400                                 /* we could deadlock if we called
1401                                    filemap_fdatawait from here so tell
1402                                    reopen_file not to flush data to
1403                                    server now */
1404                                 rc = cifs_reopen_file(open_file, false);
1405                                 if (rc != 0)
1406                                         break;
1407                         }
1408
1409                         len = min((size_t)cifs_sb->wsize,
1410                                   write_size - total_written);
1411                         /* iov[0] is reserved for smb header */
1412                         iov[1].iov_base = (char *)write_data + total_written;
1413                         iov[1].iov_len = len;
1414                         io_parms.netfid = open_file->netfid;
1415                         io_parms.pid = pid;
1416                         io_parms.tcon = pTcon;
1417                         io_parms.offset = *poffset;
1418                         io_parms.length = len;
1419                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1420                                            1, 0);
1421                 }
1422                 if (rc || (bytes_written == 0)) {
1423                         if (total_written)
1424                                 break;
1425                         else {
1426                                 FreeXid(xid);
1427                                 return rc;
1428                         }
1429                 } else {
1430                         cifs_update_eof(cifsi, *poffset, bytes_written);
1431                         *poffset += bytes_written;
1432                 }
1433         }
1434
1435         cifs_stats_bytes_written(pTcon, total_written);
1436
1437         if (total_written > 0) {
1438                 spin_lock(&dentry->d_inode->i_lock);
1439                 if (*poffset > dentry->d_inode->i_size)
1440                         i_size_write(dentry->d_inode, *poffset);
1441                 spin_unlock(&dentry->d_inode->i_lock);
1442         }
1443         mark_inode_dirty_sync(dentry->d_inode);
1444         FreeXid(xid);
1445         return total_written;
1446 }
1447
1448 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1449                                         bool fsuid_only)
1450 {
1451         struct cifsFileInfo *open_file = NULL;
1452         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1453
1454         /* only filter by fsuid on multiuser mounts */
1455         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1456                 fsuid_only = false;
1457
1458         spin_lock(&cifs_file_list_lock);
1459         /* we could simply get the first_list_entry since write-only entries
1460            are always at the end of the list but since the first entry might
1461            have a close pending, we go through the whole list */
1462         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1463                 if (fsuid_only && open_file->uid != current_fsuid())
1464                         continue;
1465                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1466                         if (!open_file->invalidHandle) {
1467                                 /* found a good file */
1468                                 /* lock it so it will not be closed on us */
1469                                 cifsFileInfo_get(open_file);
1470                                 spin_unlock(&cifs_file_list_lock);
1471                                 return open_file;
1472                         } /* else might as well continue, and look for
1473                              another, or simply have the caller reopen it
1474                              again rather than trying to fix this handle */
1475                 } else /* write only file */
1476                         break; /* write only files are last so must be done */
1477         }
1478         spin_unlock(&cifs_file_list_lock);
1479         return NULL;
1480 }
1481
1482 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1483                                         bool fsuid_only)
1484 {
1485         struct cifsFileInfo *open_file;
1486         struct cifs_sb_info *cifs_sb;
1487         bool any_available = false;
1488         int rc;
1489
1490         /* Having a null inode here (because mapping->host was set to zero by
1491         the VFS or MM) should not happen but we had reports of on oops (due to
1492         it being zero) during stress testcases so we need to check for it */
1493
1494         if (cifs_inode == NULL) {
1495                 cERROR(1, "Null inode passed to cifs_writeable_file");
1496                 dump_stack();
1497                 return NULL;
1498         }
1499
1500         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1501
1502         /* only filter by fsuid on multiuser mounts */
1503         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1504                 fsuid_only = false;
1505
1506         spin_lock(&cifs_file_list_lock);
1507 refind_writable:
1508         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1509                 if (!any_available && open_file->pid != current->tgid)
1510                         continue;
1511                 if (fsuid_only && open_file->uid != current_fsuid())
1512                         continue;
1513                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1514                         cifsFileInfo_get(open_file);
1515
1516                         if (!open_file->invalidHandle) {
1517                                 /* found a good writable file */
1518                                 spin_unlock(&cifs_file_list_lock);
1519                                 return open_file;
1520                         }
1521
1522                         spin_unlock(&cifs_file_list_lock);
1523
1524                         /* Had to unlock since following call can block */
1525                         rc = cifs_reopen_file(open_file, false);
1526                         if (!rc)
1527                                 return open_file;
1528
1529                         /* if it fails, try another handle if possible */
1530                         cFYI(1, "wp failed on reopen file");
1531                         cifsFileInfo_put(open_file);
1532
1533                         spin_lock(&cifs_file_list_lock);
1534
1535                         /* else we simply continue to the next entry. Thus
1536                            we do not loop on reopen errors.  If we
1537                            can not reopen the file, for example if we
1538                            reconnected to a server with another client
1539                            racing to delete or lock the file we would not
1540                            make progress if we restarted before the beginning
1541                            of the loop here. */
1542                 }
1543         }
1544         /* couldn't find useable FH with same pid, try any available */
1545         if (!any_available) {
1546                 any_available = true;
1547                 goto refind_writable;
1548         }
1549         spin_unlock(&cifs_file_list_lock);
1550         return NULL;
1551 }
1552
1553 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1554 {
1555         struct address_space *mapping = page->mapping;
1556         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1557         char *write_data;
1558         int rc = -EFAULT;
1559         int bytes_written = 0;
1560         struct inode *inode;
1561         struct cifsFileInfo *open_file;
1562
1563         if (!mapping || !mapping->host)
1564                 return -EFAULT;
1565
1566         inode = page->mapping->host;
1567
1568         offset += (loff_t)from;
1569         write_data = kmap(page);
1570         write_data += from;
1571
1572         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1573                 kunmap(page);
1574                 return -EIO;
1575         }
1576
1577         /* racing with truncate? */
1578         if (offset > mapping->host->i_size) {
1579                 kunmap(page);
1580                 return 0; /* don't care */
1581         }
1582
1583         /* check to make sure that we are not extending the file */
1584         if (mapping->host->i_size - offset < (loff_t)to)
1585                 to = (unsigned)(mapping->host->i_size - offset);
1586
1587         open_file = find_writable_file(CIFS_I(mapping->host), false);
1588         if (open_file) {
1589                 bytes_written = cifs_write(open_file, open_file->pid,
1590                                            write_data, to - from, &offset);
1591                 cifsFileInfo_put(open_file);
1592                 /* Does mm or vfs already set times? */
1593                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1594                 if ((bytes_written > 0) && (offset))
1595                         rc = 0;
1596                 else if (bytes_written < 0)
1597                         rc = bytes_written;
1598         } else {
1599                 cFYI(1, "No writeable filehandles for inode");
1600                 rc = -EIO;
1601         }
1602
1603         kunmap(page);
1604         return rc;
1605 }
1606
1607 static int cifs_writepages(struct address_space *mapping,
1608                            struct writeback_control *wbc)
1609 {
1610         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1611         bool done = false, scanned = false, range_whole = false;
1612         pgoff_t end, index;
1613         struct cifs_writedata *wdata;
1614         struct page *page;
1615         int rc = 0;
1616
1617         /*
1618          * If wsize is smaller than the page cache size, default to writing
1619          * one page at a time via cifs_writepage
1620          */
1621         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1622                 return generic_writepages(mapping, wbc);
1623
1624         if (wbc->range_cyclic) {
1625                 index = mapping->writeback_index; /* Start from prev offset */
1626                 end = -1;
1627         } else {
1628                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1629                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1630                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1631                         range_whole = true;
1632                 scanned = true;
1633         }
1634 retry:
1635         while (!done && index <= end) {
1636                 unsigned int i, nr_pages, found_pages;
1637                 pgoff_t next = 0, tofind;
1638                 struct page **pages;
1639
1640                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1641                                 end - index) + 1;
1642
1643                 wdata = cifs_writedata_alloc((unsigned int)tofind);
1644                 if (!wdata) {
1645                         rc = -ENOMEM;
1646                         break;
1647                 }
1648
1649                 /*
1650                  * find_get_pages_tag seems to return a max of 256 on each
1651                  * iteration, so we must call it several times in order to
1652                  * fill the array or the wsize is effectively limited to
1653                  * 256 * PAGE_CACHE_SIZE.
1654                  */
1655                 found_pages = 0;
1656                 pages = wdata->pages;
1657                 do {
1658                         nr_pages = find_get_pages_tag(mapping, &index,
1659                                                         PAGECACHE_TAG_DIRTY,
1660                                                         tofind, pages);
1661                         found_pages += nr_pages;
1662                         tofind -= nr_pages;
1663                         pages += nr_pages;
1664                 } while (nr_pages && tofind && index <= end);
1665
1666                 if (found_pages == 0) {
1667                         kref_put(&wdata->refcount, cifs_writedata_release);
1668                         break;
1669                 }
1670
1671                 nr_pages = 0;
1672                 for (i = 0; i < found_pages; i++) {
1673                         page = wdata->pages[i];
1674                         /*
1675                          * At this point we hold neither mapping->tree_lock nor
1676                          * lock on the page itself: the page may be truncated or
1677                          * invalidated (changing page->mapping to NULL), or even
1678                          * swizzled back from swapper_space to tmpfs file
1679                          * mapping
1680                          */
1681
1682                         if (nr_pages == 0)
1683                                 lock_page(page);
1684                         else if (!trylock_page(page))
1685                                 break;
1686
1687                         if (unlikely(page->mapping != mapping)) {
1688                                 unlock_page(page);
1689                                 break;
1690                         }
1691
1692                         if (!wbc->range_cyclic && page->index > end) {
1693                                 done = true;
1694                                 unlock_page(page);
1695                                 break;
1696                         }
1697
1698                         if (next && (page->index != next)) {
1699                                 /* Not next consecutive page */
1700                                 unlock_page(page);
1701                                 break;
1702                         }
1703
1704                         if (wbc->sync_mode != WB_SYNC_NONE)
1705                                 wait_on_page_writeback(page);
1706
1707                         if (PageWriteback(page) ||
1708                                         !clear_page_dirty_for_io(page)) {
1709                                 unlock_page(page);
1710                                 break;
1711                         }
1712
1713                         /*
1714                          * This actually clears the dirty bit in the radix tree.
1715                          * See cifs_writepage() for more commentary.
1716                          */
1717                         set_page_writeback(page);
1718
1719                         if (page_offset(page) >= mapping->host->i_size) {
1720                                 done = true;
1721                                 unlock_page(page);
1722                                 end_page_writeback(page);
1723                                 break;
1724                         }
1725
1726                         wdata->pages[i] = page;
1727                         next = page->index + 1;
1728                         ++nr_pages;
1729                 }
1730
1731                 /* reset index to refind any pages skipped */
1732                 if (nr_pages == 0)
1733                         index = wdata->pages[0]->index + 1;
1734
1735                 /* put any pages we aren't going to use */
1736                 for (i = nr_pages; i < found_pages; i++) {
1737                         page_cache_release(wdata->pages[i]);
1738                         wdata->pages[i] = NULL;
1739                 }
1740
1741                 /* nothing to write? */
1742                 if (nr_pages == 0) {
1743                         kref_put(&wdata->refcount, cifs_writedata_release);
1744                         continue;
1745                 }
1746
1747                 wdata->sync_mode = wbc->sync_mode;
1748                 wdata->nr_pages = nr_pages;
1749                 wdata->offset = page_offset(wdata->pages[0]);
1750
1751                 do {
1752                         if (wdata->cfile != NULL)
1753                                 cifsFileInfo_put(wdata->cfile);
1754                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1755                                                           false);
1756                         if (!wdata->cfile) {
1757                                 cERROR(1, "No writable handles for inode");
1758                                 rc = -EBADF;
1759                                 break;
1760                         }
1761                         rc = cifs_async_writev(wdata);
1762                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1763
1764                 for (i = 0; i < nr_pages; ++i)
1765                         unlock_page(wdata->pages[i]);
1766
1767                 /* send failure -- clean up the mess */
1768                 if (rc != 0) {
1769                         for (i = 0; i < nr_pages; ++i) {
1770                                 if (rc == -EAGAIN)
1771                                         redirty_page_for_writepage(wbc,
1772                                                            wdata->pages[i]);
1773                                 else
1774                                         SetPageError(wdata->pages[i]);
1775                                 end_page_writeback(wdata->pages[i]);
1776                                 page_cache_release(wdata->pages[i]);
1777                         }
1778                         if (rc != -EAGAIN)
1779                                 mapping_set_error(mapping, rc);
1780                 }
1781                 kref_put(&wdata->refcount, cifs_writedata_release);
1782
1783                 wbc->nr_to_write -= nr_pages;
1784                 if (wbc->nr_to_write <= 0)
1785                         done = true;
1786
1787                 index = next;
1788         }
1789
1790         if (!scanned && !done) {
1791                 /*
1792                  * We hit the last page and there is more work to be done: wrap
1793                  * back to the start of the file
1794                  */
1795                 scanned = true;
1796                 index = 0;
1797                 goto retry;
1798         }
1799
1800         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1801                 mapping->writeback_index = index;
1802
1803         return rc;
1804 }
1805
1806 static int
1807 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1808 {
1809         int rc;
1810         int xid;
1811
1812         xid = GetXid();
1813 /* BB add check for wbc flags */
1814         page_cache_get(page);
1815         if (!PageUptodate(page))
1816                 cFYI(1, "ppw - page not up to date");
1817
1818         /*
1819          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1820          *
1821          * A writepage() implementation always needs to do either this,
1822          * or re-dirty the page with "redirty_page_for_writepage()" in
1823          * the case of a failure.
1824          *
1825          * Just unlocking the page will cause the radix tree tag-bits
1826          * to fail to update with the state of the page correctly.
1827          */
1828         set_page_writeback(page);
1829 retry_write:
1830         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1831         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1832                 goto retry_write;
1833         else if (rc == -EAGAIN)
1834                 redirty_page_for_writepage(wbc, page);
1835         else if (rc != 0)
1836                 SetPageError(page);
1837         else
1838                 SetPageUptodate(page);
1839         end_page_writeback(page);
1840         page_cache_release(page);
1841         FreeXid(xid);
1842         return rc;
1843 }
1844
1845 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1846 {
1847         int rc = cifs_writepage_locked(page, wbc);
1848         unlock_page(page);
1849         return rc;
1850 }
1851
1852 static int cifs_write_end(struct file *file, struct address_space *mapping,
1853                         loff_t pos, unsigned len, unsigned copied,
1854                         struct page *page, void *fsdata)
1855 {
1856         int rc;
1857         struct inode *inode = mapping->host;
1858         struct cifsFileInfo *cfile = file->private_data;
1859         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1860         __u32 pid;
1861
1862         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1863                 pid = cfile->pid;
1864         else
1865                 pid = current->tgid;
1866
1867         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1868                  page, pos, copied);
1869
1870         if (PageChecked(page)) {
1871                 if (copied == len)
1872                         SetPageUptodate(page);
1873                 ClearPageChecked(page);
1874         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1875                 SetPageUptodate(page);
1876
1877         if (!PageUptodate(page)) {
1878                 char *page_data;
1879                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1880                 int xid;
1881
1882                 xid = GetXid();
1883                 /* this is probably better than directly calling
1884                    partialpage_write since in this function the file handle is
1885                    known which we might as well leverage */
1886                 /* BB check if anything else missing out of ppw
1887                    such as updating last write time */
1888                 page_data = kmap(page);
1889                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1890                 /* if (rc < 0) should we set writebehind rc? */
1891                 kunmap(page);
1892
1893                 FreeXid(xid);
1894         } else {
1895                 rc = copied;
1896                 pos += copied;
1897                 set_page_dirty(page);
1898         }
1899
1900         if (rc > 0) {
1901                 spin_lock(&inode->i_lock);
1902                 if (pos > inode->i_size)
1903                         i_size_write(inode, pos);
1904                 spin_unlock(&inode->i_lock);
1905         }
1906
1907         unlock_page(page);
1908         page_cache_release(page);
1909
1910         return rc;
1911 }
1912
1913 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1914                       int datasync)
1915 {
1916         int xid;
1917         int rc = 0;
1918         struct cifs_tcon *tcon;
1919         struct cifsFileInfo *smbfile = file->private_data;
1920         struct inode *inode = file->f_path.dentry->d_inode;
1921         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1922
1923         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1924         if (rc)
1925                 return rc;
1926         mutex_lock(&inode->i_mutex);
1927
1928         xid = GetXid();
1929
1930         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1931                 file->f_path.dentry->d_name.name, datasync);
1932
1933         if (!CIFS_I(inode)->clientCanCacheRead) {
1934                 rc = cifs_invalidate_mapping(inode);
1935                 if (rc) {
1936                         cFYI(1, "rc: %d during invalidate phase", rc);
1937                         rc = 0; /* don't care about it in fsync */
1938                 }
1939         }
1940
1941         tcon = tlink_tcon(smbfile->tlink);
1942         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1943                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1944
1945         FreeXid(xid);
1946         mutex_unlock(&inode->i_mutex);
1947         return rc;
1948 }
1949
1950 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1951 {
1952         int xid;
1953         int rc = 0;
1954         struct cifs_tcon *tcon;
1955         struct cifsFileInfo *smbfile = file->private_data;
1956         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1957         struct inode *inode = file->f_mapping->host;
1958
1959         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1960         if (rc)
1961                 return rc;
1962         mutex_lock(&inode->i_mutex);
1963
1964         xid = GetXid();
1965
1966         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1967                 file->f_path.dentry->d_name.name, datasync);
1968
1969         tcon = tlink_tcon(smbfile->tlink);
1970         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1971                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1972
1973         FreeXid(xid);
1974         mutex_unlock(&inode->i_mutex);
1975         return rc;
1976 }
1977
1978 /*
1979  * As file closes, flush all cached write data for this inode checking
1980  * for write behind errors.
1981  */
1982 int cifs_flush(struct file *file, fl_owner_t id)
1983 {
1984         struct inode *inode = file->f_path.dentry->d_inode;
1985         int rc = 0;
1986
1987         if (file->f_mode & FMODE_WRITE)
1988                 rc = filemap_write_and_wait(inode->i_mapping);
1989
1990         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1991
1992         return rc;
1993 }
1994
1995 static int
1996 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
1997 {
1998         int rc = 0;
1999         unsigned long i;
2000
2001         for (i = 0; i < num_pages; i++) {
2002                 pages[i] = alloc_page(__GFP_HIGHMEM);
2003                 if (!pages[i]) {
2004                         /*
2005                          * save number of pages we have already allocated and
2006                          * return with ENOMEM error
2007                          */
2008                         num_pages = i;
2009                         rc = -ENOMEM;
2010                         goto error;
2011                 }
2012         }
2013
2014         return rc;
2015
2016 error:
2017         for (i = 0; i < num_pages; i++)
2018                 put_page(pages[i]);
2019         return rc;
2020 }
2021
2022 static inline
2023 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2024 {
2025         size_t num_pages;
2026         size_t clen;
2027
2028         clen = min_t(const size_t, len, wsize);
2029         num_pages = clen / PAGE_CACHE_SIZE;
2030         if (clen % PAGE_CACHE_SIZE)
2031                 num_pages++;
2032
2033         if (cur_len)
2034                 *cur_len = clen;
2035
2036         return num_pages;
2037 }
2038
2039 static ssize_t
2040 cifs_iovec_write(struct file *file, const struct iovec *iov,
2041                  unsigned long nr_segs, loff_t *poffset)
2042 {
2043         unsigned int written;
2044         unsigned long num_pages, npages, i;
2045         size_t copied, len, cur_len;
2046         ssize_t total_written = 0;
2047         struct kvec *to_send;
2048         struct page **pages;
2049         struct iov_iter it;
2050         struct inode *inode;
2051         struct cifsFileInfo *open_file;
2052         struct cifs_tcon *pTcon;
2053         struct cifs_sb_info *cifs_sb;
2054         struct cifs_io_parms io_parms;
2055         int xid, rc;
2056         __u32 pid;
2057
2058         len = iov_length(iov, nr_segs);
2059         if (!len)
2060                 return 0;
2061
2062         rc = generic_write_checks(file, poffset, &len, 0);
2063         if (rc)
2064                 return rc;
2065
2066         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2067         num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2068
2069         pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2070         if (!pages)
2071                 return -ENOMEM;
2072
2073         to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2074         if (!to_send) {
2075                 kfree(pages);
2076                 return -ENOMEM;
2077         }
2078
2079         rc = cifs_write_allocate_pages(pages, num_pages);
2080         if (rc) {
2081                 kfree(pages);
2082                 kfree(to_send);
2083                 return rc;
2084         }
2085
2086         xid = GetXid();
2087         open_file = file->private_data;
2088
2089         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2090                 pid = open_file->pid;
2091         else
2092                 pid = current->tgid;
2093
2094         pTcon = tlink_tcon(open_file->tlink);
2095         inode = file->f_path.dentry->d_inode;
2096
2097         iov_iter_init(&it, iov, nr_segs, len, 0);
2098         npages = num_pages;
2099
2100         do {
2101                 size_t save_len = cur_len;
2102                 for (i = 0; i < npages; i++) {
2103                         copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2104                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
2105                                                          copied);
2106                         cur_len -= copied;
2107                         iov_iter_advance(&it, copied);
2108                         to_send[i+1].iov_base = kmap(pages[i]);
2109                         to_send[i+1].iov_len = copied;
2110                 }
2111
2112                 cur_len = save_len - cur_len;
2113
2114                 do {
2115                         if (open_file->invalidHandle) {
2116                                 rc = cifs_reopen_file(open_file, false);
2117                                 if (rc != 0)
2118                                         break;
2119                         }
2120                         io_parms.netfid = open_file->netfid;
2121                         io_parms.pid = pid;
2122                         io_parms.tcon = pTcon;
2123                         io_parms.offset = *poffset;
2124                         io_parms.length = cur_len;
2125                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2126                                            npages, 0);
2127                 } while (rc == -EAGAIN);
2128
2129                 for (i = 0; i < npages; i++)
2130                         kunmap(pages[i]);
2131
2132                 if (written) {
2133                         len -= written;
2134                         total_written += written;
2135                         cifs_update_eof(CIFS_I(inode), *poffset, written);
2136                         *poffset += written;
2137                 } else if (rc < 0) {
2138                         if (!total_written)
2139                                 total_written = rc;
2140                         break;
2141                 }
2142
2143                 /* get length and number of kvecs of the next write */
2144                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2145         } while (len > 0);
2146
2147         if (total_written > 0) {
2148                 spin_lock(&inode->i_lock);
2149                 if (*poffset > inode->i_size)
2150                         i_size_write(inode, *poffset);
2151                 spin_unlock(&inode->i_lock);
2152         }
2153
2154         cifs_stats_bytes_written(pTcon, total_written);
2155         mark_inode_dirty_sync(inode);
2156
2157         for (i = 0; i < num_pages; i++)
2158                 put_page(pages[i]);
2159         kfree(to_send);
2160         kfree(pages);
2161         FreeXid(xid);
2162         return total_written;
2163 }
2164
2165 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2166                                 unsigned long nr_segs, loff_t pos)
2167 {
2168         ssize_t written;
2169         struct inode *inode;
2170
2171         inode = iocb->ki_filp->f_path.dentry->d_inode;
2172
2173         /*
2174          * BB - optimize the way when signing is disabled. We can drop this
2175          * extra memory-to-memory copying and use iovec buffers for constructing
2176          * write request.
2177          */
2178
2179         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2180         if (written > 0) {
2181                 CIFS_I(inode)->invalid_mapping = true;
2182                 iocb->ki_pos = pos;
2183         }
2184
2185         return written;
2186 }
2187
2188 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2189                            unsigned long nr_segs, loff_t pos)
2190 {
2191         struct inode *inode;
2192
2193         inode = iocb->ki_filp->f_path.dentry->d_inode;
2194
2195         if (CIFS_I(inode)->clientCanCacheAll)
2196                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2197
2198         /*
2199          * In strict cache mode we need to write the data to the server exactly
2200          * from the pos to pos+len-1 rather than flush all affected pages
2201          * because it may cause a error with mandatory locks on these pages but
2202          * not on the region from pos to ppos+len-1.
2203          */
2204
2205         return cifs_user_writev(iocb, iov, nr_segs, pos);
2206 }
2207
2208 static ssize_t
2209 cifs_iovec_read(struct file *file, const struct iovec *iov,
2210                  unsigned long nr_segs, loff_t *poffset)
2211 {
2212         int rc;
2213         int xid;
2214         ssize_t total_read;
2215         unsigned int bytes_read = 0;
2216         size_t len, cur_len;
2217         int iov_offset = 0;
2218         struct cifs_sb_info *cifs_sb;
2219         struct cifs_tcon *pTcon;
2220         struct cifsFileInfo *open_file;
2221         struct smb_com_read_rsp *pSMBr;
2222         struct cifs_io_parms io_parms;
2223         char *read_data;
2224         unsigned int rsize;
2225         __u32 pid;
2226
2227         if (!nr_segs)
2228                 return 0;
2229
2230         len = iov_length(iov, nr_segs);
2231         if (!len)
2232                 return 0;
2233
2234         xid = GetXid();
2235         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2236
2237         /* FIXME: set up handlers for larger reads and/or convert to async */
2238         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2239
2240         open_file = file->private_data;
2241         pTcon = tlink_tcon(open_file->tlink);
2242
2243         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2244                 pid = open_file->pid;
2245         else
2246                 pid = current->tgid;
2247
2248         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2249                 cFYI(1, "attempting read on write only file instance");
2250
2251         for (total_read = 0; total_read < len; total_read += bytes_read) {
2252                 cur_len = min_t(const size_t, len - total_read, rsize);
2253                 rc = -EAGAIN;
2254                 read_data = NULL;
2255
2256                 while (rc == -EAGAIN) {
2257                         int buf_type = CIFS_NO_BUFFER;
2258                         if (open_file->invalidHandle) {
2259                                 rc = cifs_reopen_file(open_file, true);
2260                                 if (rc != 0)
2261                                         break;
2262                         }
2263                         io_parms.netfid = open_file->netfid;
2264                         io_parms.pid = pid;
2265                         io_parms.tcon = pTcon;
2266                         io_parms.offset = *poffset;
2267                         io_parms.length = cur_len;
2268                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2269                                          &read_data, &buf_type);
2270                         pSMBr = (struct smb_com_read_rsp *)read_data;
2271                         if (read_data) {
2272                                 char *data_offset = read_data + 4 +
2273                                                 le16_to_cpu(pSMBr->DataOffset);
2274                                 if (memcpy_toiovecend(iov, data_offset,
2275                                                       iov_offset, bytes_read))
2276                                         rc = -EFAULT;
2277                                 if (buf_type == CIFS_SMALL_BUFFER)
2278                                         cifs_small_buf_release(read_data);
2279                                 else if (buf_type == CIFS_LARGE_BUFFER)
2280                                         cifs_buf_release(read_data);
2281                                 read_data = NULL;
2282                                 iov_offset += bytes_read;
2283                         }
2284                 }
2285
2286                 if (rc || (bytes_read == 0)) {
2287                         if (total_read) {
2288                                 break;
2289                         } else {
2290                                 FreeXid(xid);
2291                                 return rc;
2292                         }
2293                 } else {
2294                         cifs_stats_bytes_read(pTcon, bytes_read);
2295                         *poffset += bytes_read;
2296                 }
2297         }
2298
2299         FreeXid(xid);
2300         return total_read;
2301 }
2302
2303 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2304                                unsigned long nr_segs, loff_t pos)
2305 {
2306         ssize_t read;
2307
2308         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2309         if (read > 0)
2310                 iocb->ki_pos = pos;
2311
2312         return read;
2313 }
2314
2315 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2316                           unsigned long nr_segs, loff_t pos)
2317 {
2318         struct inode *inode;
2319
2320         inode = iocb->ki_filp->f_path.dentry->d_inode;
2321
2322         if (CIFS_I(inode)->clientCanCacheRead)
2323                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2324
2325         /*
2326          * In strict cache mode we need to read from the server all the time
2327          * if we don't have level II oplock because the server can delay mtime
2328          * change - so we can't make a decision about inode invalidating.
2329          * And we can also fail with pagereading if there are mandatory locks
2330          * on pages affected by this read but not on the region from pos to
2331          * pos+len-1.
2332          */
2333
2334         return cifs_user_readv(iocb, iov, nr_segs, pos);
2335 }
2336
2337 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2338                          loff_t *poffset)
2339 {
2340         int rc = -EACCES;
2341         unsigned int bytes_read = 0;
2342         unsigned int total_read;
2343         unsigned int current_read_size;
2344         unsigned int rsize;
2345         struct cifs_sb_info *cifs_sb;
2346         struct cifs_tcon *pTcon;
2347         int xid;
2348         char *current_offset;
2349         struct cifsFileInfo *open_file;
2350         struct cifs_io_parms io_parms;
2351         int buf_type = CIFS_NO_BUFFER;
2352         __u32 pid;
2353
2354         xid = GetXid();
2355         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2356
2357         /* FIXME: set up handlers for larger reads and/or convert to async */
2358         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2359
2360         if (file->private_data == NULL) {
2361                 rc = -EBADF;
2362                 FreeXid(xid);
2363                 return rc;
2364         }
2365         open_file = file->private_data;
2366         pTcon = tlink_tcon(open_file->tlink);
2367
2368         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2369                 pid = open_file->pid;
2370         else
2371                 pid = current->tgid;
2372
2373         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2374                 cFYI(1, "attempting read on write only file instance");
2375
2376         for (total_read = 0, current_offset = read_data;
2377              read_size > total_read;
2378              total_read += bytes_read, current_offset += bytes_read) {
2379                 current_read_size = min_t(uint, read_size - total_read, rsize);
2380
2381                 /* For windows me and 9x we do not want to request more
2382                 than it negotiated since it will refuse the read then */
2383                 if ((pTcon->ses) &&
2384                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2385                         current_read_size = min_t(uint, current_read_size,
2386                                         CIFSMaxBufSize);
2387                 }
2388                 rc = -EAGAIN;
2389                 while (rc == -EAGAIN) {
2390                         if (open_file->invalidHandle) {
2391                                 rc = cifs_reopen_file(open_file, true);
2392                                 if (rc != 0)
2393                                         break;
2394                         }
2395                         io_parms.netfid = open_file->netfid;
2396                         io_parms.pid = pid;
2397                         io_parms.tcon = pTcon;
2398                         io_parms.offset = *poffset;
2399                         io_parms.length = current_read_size;
2400                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2401                                          &current_offset, &buf_type);
2402                 }
2403                 if (rc || (bytes_read == 0)) {
2404                         if (total_read) {
2405                                 break;
2406                         } else {
2407                                 FreeXid(xid);
2408                                 return rc;
2409                         }
2410                 } else {
2411                         cifs_stats_bytes_read(pTcon, total_read);
2412                         *poffset += bytes_read;
2413                 }
2414         }
2415         FreeXid(xid);
2416         return total_read;
2417 }
2418
2419 /*
2420  * If the page is mmap'ed into a process' page tables, then we need to make
2421  * sure that it doesn't change while being written back.
2422  */
2423 static int
2424 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2425 {
2426         struct page *page = vmf->page;
2427
2428         lock_page(page);
2429         return VM_FAULT_LOCKED;
2430 }
2431
2432 static struct vm_operations_struct cifs_file_vm_ops = {
2433         .fault = filemap_fault,
2434         .page_mkwrite = cifs_page_mkwrite,
2435 };
2436
2437 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2438 {
2439         int rc, xid;
2440         struct inode *inode = file->f_path.dentry->d_inode;
2441
2442         xid = GetXid();
2443
2444         if (!CIFS_I(inode)->clientCanCacheRead) {
2445                 rc = cifs_invalidate_mapping(inode);
2446                 if (rc)
2447                         return rc;
2448         }
2449
2450         rc = generic_file_mmap(file, vma);
2451         if (rc == 0)
2452                 vma->vm_ops = &cifs_file_vm_ops;
2453         FreeXid(xid);
2454         return rc;
2455 }
2456
2457 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2458 {
2459         int rc, xid;
2460
2461         xid = GetXid();
2462         rc = cifs_revalidate_file(file);
2463         if (rc) {
2464                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2465                 FreeXid(xid);
2466                 return rc;
2467         }
2468         rc = generic_file_mmap(file, vma);
2469         if (rc == 0)
2470                 vma->vm_ops = &cifs_file_vm_ops;
2471         FreeXid(xid);
2472         return rc;
2473 }
2474
2475 static int cifs_readpages(struct file *file, struct address_space *mapping,
2476         struct list_head *page_list, unsigned num_pages)
2477 {
2478         int rc;
2479         struct list_head tmplist;
2480         struct cifsFileInfo *open_file = file->private_data;
2481         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2482         unsigned int rsize = cifs_sb->rsize;
2483         pid_t pid;
2484
2485         /*
2486          * Give up immediately if rsize is too small to read an entire page.
2487          * The VFS will fall back to readpage. We should never reach this
2488          * point however since we set ra_pages to 0 when the rsize is smaller
2489          * than a cache page.
2490          */
2491         if (unlikely(rsize < PAGE_CACHE_SIZE))
2492                 return 0;
2493
2494         /*
2495          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2496          * immediately if the cookie is negative
2497          */
2498         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2499                                          &num_pages);
2500         if (rc == 0)
2501                 return rc;
2502
2503         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2504                 pid = open_file->pid;
2505         else
2506                 pid = current->tgid;
2507
2508         rc = 0;
2509         INIT_LIST_HEAD(&tmplist);
2510
2511         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2512                 mapping, num_pages);
2513
2514         /*
2515          * Start with the page at end of list and move it to private
2516          * list. Do the same with any following pages until we hit
2517          * the rsize limit, hit an index discontinuity, or run out of
2518          * pages. Issue the async read and then start the loop again
2519          * until the list is empty.
2520          *
2521          * Note that list order is important. The page_list is in
2522          * the order of declining indexes. When we put the pages in
2523          * the rdata->pages, then we want them in increasing order.
2524          */
2525         while (!list_empty(page_list)) {
2526                 unsigned int bytes = PAGE_CACHE_SIZE;
2527                 unsigned int expected_index;
2528                 unsigned int nr_pages = 1;
2529                 loff_t offset;
2530                 struct page *page, *tpage;
2531                 struct cifs_readdata *rdata;
2532
2533                 page = list_entry(page_list->prev, struct page, lru);
2534
2535                 /*
2536                  * Lock the page and put it in the cache. Since no one else
2537                  * should have access to this page, we're safe to simply set
2538                  * PG_locked without checking it first.
2539                  */
2540                 __set_page_locked(page);
2541                 rc = add_to_page_cache_locked(page, mapping,
2542                                               page->index, GFP_KERNEL);
2543
2544                 /* give up if we can't stick it in the cache */
2545                 if (rc) {
2546                         __clear_page_locked(page);
2547                         break;
2548                 }
2549
2550                 /* move first page to the tmplist */
2551                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2552                 list_move_tail(&page->lru, &tmplist);
2553
2554                 /* now try and add more pages onto the request */
2555                 expected_index = page->index + 1;
2556                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2557                         /* discontinuity ? */
2558                         if (page->index != expected_index)
2559                                 break;
2560
2561                         /* would this page push the read over the rsize? */
2562                         if (bytes + PAGE_CACHE_SIZE > rsize)
2563                                 break;
2564
2565                         __set_page_locked(page);
2566                         if (add_to_page_cache_locked(page, mapping,
2567                                                 page->index, GFP_KERNEL)) {
2568                                 __clear_page_locked(page);
2569                                 break;
2570                         }
2571                         list_move_tail(&page->lru, &tmplist);
2572                         bytes += PAGE_CACHE_SIZE;
2573                         expected_index++;
2574                         nr_pages++;
2575                 }
2576
2577                 rdata = cifs_readdata_alloc(nr_pages);
2578                 if (!rdata) {
2579                         /* best to give up if we're out of mem */
2580                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2581                                 list_del(&page->lru);
2582                                 lru_cache_add_file(page);
2583                                 unlock_page(page);
2584                                 page_cache_release(page);
2585                         }
2586                         rc = -ENOMEM;
2587                         break;
2588                 }
2589
2590                 spin_lock(&cifs_file_list_lock);
2591                 cifsFileInfo_get(open_file);
2592                 spin_unlock(&cifs_file_list_lock);
2593                 rdata->cfile = open_file;
2594                 rdata->mapping = mapping;
2595                 rdata->offset = offset;
2596                 rdata->bytes = bytes;
2597                 rdata->pid = pid;
2598                 list_splice_init(&tmplist, &rdata->pages);
2599
2600                 do {
2601                         if (open_file->invalidHandle) {
2602                                 rc = cifs_reopen_file(open_file, true);
2603                                 if (rc != 0)
2604                                         continue;
2605                         }
2606                         rc = cifs_async_readv(rdata);
2607                 } while (rc == -EAGAIN);
2608
2609                 if (rc != 0) {
2610                         list_for_each_entry_safe(page, tpage, &rdata->pages,
2611                                                  lru) {
2612                                 list_del(&page->lru);
2613                                 lru_cache_add_file(page);
2614                                 unlock_page(page);
2615                                 page_cache_release(page);
2616                         }
2617                         cifs_readdata_free(rdata);
2618                         break;
2619                 }
2620         }
2621
2622         return rc;
2623 }
2624
2625 static int cifs_readpage_worker(struct file *file, struct page *page,
2626         loff_t *poffset)
2627 {
2628         char *read_data;
2629         int rc;
2630
2631         /* Is the page cached? */
2632         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2633         if (rc == 0)
2634                 goto read_complete;
2635
2636         page_cache_get(page);
2637         read_data = kmap(page);
2638         /* for reads over a certain size could initiate async read ahead */
2639
2640         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2641
2642         if (rc < 0)
2643                 goto io_error;
2644         else
2645                 cFYI(1, "Bytes read %d", rc);
2646
2647         file->f_path.dentry->d_inode->i_atime =
2648                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2649
2650         if (PAGE_CACHE_SIZE > rc)
2651                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2652
2653         flush_dcache_page(page);
2654         SetPageUptodate(page);
2655
2656         /* send this page to the cache */
2657         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2658
2659         rc = 0;
2660
2661 io_error:
2662         kunmap(page);
2663         page_cache_release(page);
2664
2665 read_complete:
2666         return rc;
2667 }
2668
2669 static int cifs_readpage(struct file *file, struct page *page)
2670 {
2671         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2672         int rc = -EACCES;
2673         int xid;
2674
2675         xid = GetXid();
2676
2677         if (file->private_data == NULL) {
2678                 rc = -EBADF;
2679                 FreeXid(xid);
2680                 return rc;
2681         }
2682
2683         cFYI(1, "readpage %p at offset %d 0x%x\n",
2684                  page, (int)offset, (int)offset);
2685
2686         rc = cifs_readpage_worker(file, page, &offset);
2687
2688         unlock_page(page);
2689
2690         FreeXid(xid);
2691         return rc;
2692 }
2693
2694 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2695 {
2696         struct cifsFileInfo *open_file;
2697
2698         spin_lock(&cifs_file_list_lock);
2699         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2700                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2701                         spin_unlock(&cifs_file_list_lock);
2702                         return 1;
2703                 }
2704         }
2705         spin_unlock(&cifs_file_list_lock);
2706         return 0;
2707 }
2708
2709 /* We do not want to update the file size from server for inodes
2710    open for write - to avoid races with writepage extending
2711    the file - in the future we could consider allowing
2712    refreshing the inode only on increases in the file size
2713    but this is tricky to do without racing with writebehind
2714    page caching in the current Linux kernel design */
2715 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2716 {
2717         if (!cifsInode)
2718                 return true;
2719
2720         if (is_inode_writable(cifsInode)) {
2721                 /* This inode is open for write at least once */
2722                 struct cifs_sb_info *cifs_sb;
2723
2724                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2725                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2726                         /* since no page cache to corrupt on directio
2727                         we can change size safely */
2728                         return true;
2729                 }
2730
2731                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2732                         return true;
2733
2734                 return false;
2735         } else
2736                 return true;
2737 }
2738
2739 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2740                         loff_t pos, unsigned len, unsigned flags,
2741                         struct page **pagep, void **fsdata)
2742 {
2743         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2744         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2745         loff_t page_start = pos & PAGE_MASK;
2746         loff_t i_size;
2747         struct page *page;
2748         int rc = 0;
2749
2750         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2751
2752         page = grab_cache_page_write_begin(mapping, index, flags);
2753         if (!page) {
2754                 rc = -ENOMEM;
2755                 goto out;
2756         }
2757
2758         if (PageUptodate(page))
2759                 goto out;
2760
2761         /*
2762          * If we write a full page it will be up to date, no need to read from
2763          * the server. If the write is short, we'll end up doing a sync write
2764          * instead.
2765          */
2766         if (len == PAGE_CACHE_SIZE)
2767                 goto out;
2768
2769         /*
2770          * optimize away the read when we have an oplock, and we're not
2771          * expecting to use any of the data we'd be reading in. That
2772          * is, when the page lies beyond the EOF, or straddles the EOF
2773          * and the write will cover all of the existing data.
2774          */
2775         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2776                 i_size = i_size_read(mapping->host);
2777                 if (page_start >= i_size ||
2778                     (offset == 0 && (pos + len) >= i_size)) {
2779                         zero_user_segments(page, 0, offset,
2780                                            offset + len,
2781                                            PAGE_CACHE_SIZE);
2782                         /*
2783                          * PageChecked means that the parts of the page
2784                          * to which we're not writing are considered up
2785                          * to date. Once the data is copied to the
2786                          * page, it can be set uptodate.
2787                          */
2788                         SetPageChecked(page);
2789                         goto out;
2790                 }
2791         }
2792
2793         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2794                 /*
2795                  * might as well read a page, it is fast enough. If we get
2796                  * an error, we don't need to return it. cifs_write_end will
2797                  * do a sync write instead since PG_uptodate isn't set.
2798                  */
2799                 cifs_readpage_worker(file, page, &page_start);
2800         } else {
2801                 /* we could try using another file handle if there is one -
2802                    but how would we lock it to prevent close of that handle
2803                    racing with this read? In any case
2804                    this will be written out by write_end so is fine */
2805         }
2806 out:
2807         *pagep = page;
2808         return rc;
2809 }
2810
2811 static int cifs_release_page(struct page *page, gfp_t gfp)
2812 {
2813         if (PagePrivate(page))
2814                 return 0;
2815
2816         return cifs_fscache_release_page(page, gfp);
2817 }
2818
2819 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2820 {
2821         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2822
2823         if (offset == 0)
2824                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2825 }
2826
2827 static int cifs_launder_page(struct page *page)
2828 {
2829         int rc = 0;
2830         loff_t range_start = page_offset(page);
2831         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2832         struct writeback_control wbc = {
2833                 .sync_mode = WB_SYNC_ALL,
2834                 .nr_to_write = 0,
2835                 .range_start = range_start,
2836                 .range_end = range_end,
2837         };
2838
2839         cFYI(1, "Launder page: %p", page);
2840
2841         if (clear_page_dirty_for_io(page))
2842                 rc = cifs_writepage_locked(page, &wbc);
2843
2844         cifs_fscache_invalidate_page(page, page->mapping->host);
2845         return rc;
2846 }
2847
2848 void cifs_oplock_break(struct work_struct *work)
2849 {
2850         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2851                                                   oplock_break);
2852         struct inode *inode = cfile->dentry->d_inode;
2853         struct cifsInodeInfo *cinode = CIFS_I(inode);
2854         int rc = 0;
2855
2856         if (inode && S_ISREG(inode->i_mode)) {
2857                 if (cinode->clientCanCacheRead)
2858                         break_lease(inode, O_RDONLY);
2859                 else
2860                         break_lease(inode, O_WRONLY);
2861                 rc = filemap_fdatawrite(inode->i_mapping);
2862                 if (cinode->clientCanCacheRead == 0) {
2863                         rc = filemap_fdatawait(inode->i_mapping);
2864                         mapping_set_error(inode->i_mapping, rc);
2865                         invalidate_remote_inode(inode);
2866                 }
2867                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2868         }
2869
2870         rc = cifs_push_locks(cfile);
2871         if (rc)
2872                 cERROR(1, "Push locks rc = %d", rc);
2873
2874         /*
2875          * releasing stale oplock after recent reconnect of smb session using
2876          * a now incorrect file handle is not a data integrity issue but do
2877          * not bother sending an oplock release if session to server still is
2878          * disconnected since oplock already released by the server
2879          */
2880         if (!cfile->oplock_break_cancelled) {
2881                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2882                                  current->tgid, 0, 0, 0, 0,
2883                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
2884                                  cinode->clientCanCacheRead ? 1 : 0);
2885                 cFYI(1, "Oplock release rc = %d", rc);
2886         }
2887 }
2888
2889 const struct address_space_operations cifs_addr_ops = {
2890         .readpage = cifs_readpage,
2891         .readpages = cifs_readpages,
2892         .writepage = cifs_writepage,
2893         .writepages = cifs_writepages,
2894         .write_begin = cifs_write_begin,
2895         .write_end = cifs_write_end,
2896         .set_page_dirty = __set_page_dirty_nobuffers,
2897         .releasepage = cifs_release_page,
2898         .invalidatepage = cifs_invalidate_page,
2899         .launder_page = cifs_launder_page,
2900 };
2901
2902 /*
2903  * cifs_readpages requires the server to support a buffer large enough to
2904  * contain the header plus one complete page of data.  Otherwise, we need
2905  * to leave cifs_readpages out of the address space operations.
2906  */
2907 const struct address_space_operations cifs_addr_ops_smallbuf = {
2908         .readpage = cifs_readpage,
2909         .writepage = cifs_writepage,
2910         .writepages = cifs_writepages,
2911         .write_begin = cifs_write_begin,
2912         .write_end = cifs_write_end,
2913         .set_page_dirty = __set_page_dirty_nobuffers,
2914         .releasepage = cifs_release_page,
2915         .invalidatepage = cifs_invalidate_page,
2916         .launder_page = cifs_launder_page,
2917 };