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