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