fs/cifs/file.c

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