fs/cifs/file.c

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