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