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