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