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