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 bytes, 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                         bytes = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2169                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
2170                                                          bytes);
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                          * If we didn't copy as much as we expected, then that
2177                          * may mean we trod into an unmapped area. Stop copying
2178                          * at that point. On the next pass through the big
2179                          * loop, we'll likely end up getting a zero-length
2180                          * write and bailing out of it.
2181                          */
2182                         if (copied < bytes)
2183                                 break;
2184                 }
2185
2186                 cur_len = save_len - cur_len;
2187
2188                 /*
2189                  * If we have no data to send, then that probably means that
2190                  * the copy above failed altogether. That's most likely because
2191                  * the address in the iovec was bogus. Set the rc to -EFAULT,
2192                  * free anything we allocated and bail out.
2193                  */
2194                 if (!cur_len) {
2195                         kunmap(pages[0]);
2196                         if (!total_written)
2197                                 total_written = -EFAULT;
2198                         break;
2199                 }
2200
2201                 /*
2202                  * i + 1 now represents the number of pages we actually used in
2203                  * the copy phase above.
2204                  */
2205                 npages = min(npages, i + 1);
2206
2207                 do {
2208                         if (open_file->invalidHandle) {
2209                                 rc = cifs_reopen_file(open_file, false);
2210                                 if (rc != 0)
2211                                         break;
2212                         }
2213                         io_parms.netfid = open_file->netfid;
2214                         io_parms.pid = pid;
2215                         io_parms.tcon = pTcon;
2216                         io_parms.offset = *poffset;
2217                         io_parms.length = cur_len;
2218                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2219                                            npages, 0);
2220                 } while (rc == -EAGAIN);
2221
2222                 for (i = 0; i < npages; i++)
2223                         kunmap(pages[i]);
2224
2225                 if (written) {
2226                         len -= written;
2227                         total_written += written;
2228                         cifs_update_eof(CIFS_I(inode), *poffset, written);
2229                         *poffset += written;
2230                 } else if (rc < 0) {
2231                         if (!total_written)
2232                                 total_written = rc;
2233                         break;
2234                 }
2235
2236                 /* get length and number of kvecs of the next write */
2237                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2238         } while (len > 0);
2239
2240         if (total_written > 0) {
2241                 spin_lock(&inode->i_lock);
2242                 if (*poffset > inode->i_size)
2243                         i_size_write(inode, *poffset);
2244                 spin_unlock(&inode->i_lock);
2245         }
2246
2247         cifs_stats_bytes_written(pTcon, total_written);
2248         mark_inode_dirty_sync(inode);
2249
2250         for (i = 0; i < num_pages; i++)
2251                 put_page(pages[i]);
2252         kfree(to_send);
2253         kfree(pages);
2254         FreeXid(xid);
2255         return total_written;
2256 }
2257
2258 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2259                                 unsigned long nr_segs, loff_t pos)
2260 {
2261         ssize_t written;
2262         struct inode *inode;
2263
2264         inode = iocb->ki_filp->f_path.dentry->d_inode;
2265
2266         /*
2267          * BB - optimize the way when signing is disabled. We can drop this
2268          * extra memory-to-memory copying and use iovec buffers for constructing
2269          * write request.
2270          */
2271
2272         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2273         if (written > 0) {
2274                 CIFS_I(inode)->invalid_mapping = true;
2275                 iocb->ki_pos = pos;
2276         }
2277
2278         return written;
2279 }
2280
2281 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2282                            unsigned long nr_segs, loff_t pos)
2283 {
2284         struct inode *inode;
2285
2286         inode = iocb->ki_filp->f_path.dentry->d_inode;
2287
2288         if (CIFS_I(inode)->clientCanCacheAll)
2289                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2290
2291         /*
2292          * In strict cache mode we need to write the data to the server exactly
2293          * from the pos to pos+len-1 rather than flush all affected pages
2294          * because it may cause a error with mandatory locks on these pages but
2295          * not on the region from pos to ppos+len-1.
2296          */
2297
2298         return cifs_user_writev(iocb, iov, nr_segs, pos);
2299 }
2300
2301 static ssize_t
2302 cifs_iovec_read(struct file *file, const struct iovec *iov,
2303                  unsigned long nr_segs, loff_t *poffset)
2304 {
2305         int rc;
2306         int xid;
2307         ssize_t total_read;
2308         unsigned int bytes_read = 0;
2309         size_t len, cur_len;
2310         int iov_offset = 0;
2311         struct cifs_sb_info *cifs_sb;
2312         struct cifs_tcon *pTcon;
2313         struct cifsFileInfo *open_file;
2314         struct smb_com_read_rsp *pSMBr;
2315         struct cifs_io_parms io_parms;
2316         char *read_data;
2317         unsigned int rsize;
2318         __u32 pid;
2319
2320         if (!nr_segs)
2321                 return 0;
2322
2323         len = iov_length(iov, nr_segs);
2324         if (!len)
2325                 return 0;
2326
2327         xid = GetXid();
2328         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2329
2330         /* FIXME: set up handlers for larger reads and/or convert to async */
2331         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2332
2333         open_file = file->private_data;
2334         pTcon = tlink_tcon(open_file->tlink);
2335
2336         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2337                 pid = open_file->pid;
2338         else
2339                 pid = current->tgid;
2340
2341         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2342                 cFYI(1, "attempting read on write only file instance");
2343
2344         for (total_read = 0; total_read < len; total_read += bytes_read) {
2345                 cur_len = min_t(const size_t, len - total_read, rsize);
2346                 rc = -EAGAIN;
2347                 read_data = NULL;
2348
2349                 while (rc == -EAGAIN) {
2350                         int buf_type = CIFS_NO_BUFFER;
2351                         if (open_file->invalidHandle) {
2352                                 rc = cifs_reopen_file(open_file, true);
2353                                 if (rc != 0)
2354                                         break;
2355                         }
2356                         io_parms.netfid = open_file->netfid;
2357                         io_parms.pid = pid;
2358                         io_parms.tcon = pTcon;
2359                         io_parms.offset = *poffset;
2360                         io_parms.length = cur_len;
2361                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2362                                          &read_data, &buf_type);
2363                         pSMBr = (struct smb_com_read_rsp *)read_data;
2364                         if (read_data) {
2365                                 char *data_offset = read_data + 4 +
2366                                                 le16_to_cpu(pSMBr->DataOffset);
2367                                 if (memcpy_toiovecend(iov, data_offset,
2368                                                       iov_offset, bytes_read))
2369                                         rc = -EFAULT;
2370                                 if (buf_type == CIFS_SMALL_BUFFER)
2371                                         cifs_small_buf_release(read_data);
2372                                 else if (buf_type == CIFS_LARGE_BUFFER)
2373                                         cifs_buf_release(read_data);
2374                                 read_data = NULL;
2375                                 iov_offset += bytes_read;
2376                         }
2377                 }
2378
2379                 if (rc || (bytes_read == 0)) {
2380                         if (total_read) {
2381                                 break;
2382                         } else {
2383                                 FreeXid(xid);
2384                                 return rc;
2385                         }
2386                 } else {
2387                         cifs_stats_bytes_read(pTcon, bytes_read);
2388                         *poffset += bytes_read;
2389                 }
2390         }
2391
2392         FreeXid(xid);
2393         return total_read;
2394 }
2395
2396 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2397                                unsigned long nr_segs, loff_t pos)
2398 {
2399         ssize_t read;
2400
2401         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2402         if (read > 0)
2403                 iocb->ki_pos = pos;
2404
2405         return read;
2406 }
2407
2408 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2409                           unsigned long nr_segs, loff_t pos)
2410 {
2411         struct inode *inode;
2412
2413         inode = iocb->ki_filp->f_path.dentry->d_inode;
2414
2415         if (CIFS_I(inode)->clientCanCacheRead)
2416                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2417
2418         /*
2419          * In strict cache mode we need to read from the server all the time
2420          * if we don't have level II oplock because the server can delay mtime
2421          * change - so we can't make a decision about inode invalidating.
2422          * And we can also fail with pagereading if there are mandatory locks
2423          * on pages affected by this read but not on the region from pos to
2424          * pos+len-1.
2425          */
2426
2427         return cifs_user_readv(iocb, iov, nr_segs, pos);
2428 }
2429
2430 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2431                          loff_t *poffset)
2432 {
2433         int rc = -EACCES;
2434         unsigned int bytes_read = 0;
2435         unsigned int total_read;
2436         unsigned int current_read_size;
2437         unsigned int rsize;
2438         struct cifs_sb_info *cifs_sb;
2439         struct cifs_tcon *pTcon;
2440         int xid;
2441         char *current_offset;
2442         struct cifsFileInfo *open_file;
2443         struct cifs_io_parms io_parms;
2444         int buf_type = CIFS_NO_BUFFER;
2445         __u32 pid;
2446
2447         xid = GetXid();
2448         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2449
2450         /* FIXME: set up handlers for larger reads and/or convert to async */
2451         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2452
2453         if (file->private_data == NULL) {
2454                 rc = -EBADF;
2455                 FreeXid(xid);
2456                 return rc;
2457         }
2458         open_file = file->private_data;
2459         pTcon = tlink_tcon(open_file->tlink);
2460
2461         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2462                 pid = open_file->pid;
2463         else
2464                 pid = current->tgid;
2465
2466         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2467                 cFYI(1, "attempting read on write only file instance");
2468
2469         for (total_read = 0, current_offset = read_data;
2470              read_size > total_read;
2471              total_read += bytes_read, current_offset += bytes_read) {
2472                 current_read_size = min_t(uint, read_size - total_read, rsize);
2473
2474                 /* For windows me and 9x we do not want to request more
2475                 than it negotiated since it will refuse the read then */
2476                 if ((pTcon->ses) &&
2477                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2478                         current_read_size = min_t(uint, current_read_size,
2479                                         CIFSMaxBufSize);
2480                 }
2481                 rc = -EAGAIN;
2482                 while (rc == -EAGAIN) {
2483                         if (open_file->invalidHandle) {
2484                                 rc = cifs_reopen_file(open_file, true);
2485                                 if (rc != 0)
2486                                         break;
2487                         }
2488                         io_parms.netfid = open_file->netfid;
2489                         io_parms.pid = pid;
2490                         io_parms.tcon = pTcon;
2491                         io_parms.offset = *poffset;
2492                         io_parms.length = current_read_size;
2493                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2494                                          &current_offset, &buf_type);
2495                 }
2496                 if (rc || (bytes_read == 0)) {
2497                         if (total_read) {
2498                                 break;
2499                         } else {
2500                                 FreeXid(xid);
2501                                 return rc;
2502                         }
2503                 } else {
2504                         cifs_stats_bytes_read(pTcon, total_read);
2505                         *poffset += bytes_read;
2506                 }
2507         }
2508         FreeXid(xid);
2509         return total_read;
2510 }
2511
2512 /*
2513  * If the page is mmap'ed into a process' page tables, then we need to make
2514  * sure that it doesn't change while being written back.
2515  */
2516 static int
2517 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2518 {
2519         struct page *page = vmf->page;
2520
2521         lock_page(page);
2522         return VM_FAULT_LOCKED;
2523 }
2524
2525 static struct vm_operations_struct cifs_file_vm_ops = {
2526         .fault = filemap_fault,
2527         .page_mkwrite = cifs_page_mkwrite,
2528 };
2529
2530 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2531 {
2532         int rc, xid;
2533         struct inode *inode = file->f_path.dentry->d_inode;
2534
2535         xid = GetXid();
2536
2537         if (!CIFS_I(inode)->clientCanCacheRead) {
2538                 rc = cifs_invalidate_mapping(inode);
2539                 if (rc)
2540                         return rc;
2541         }
2542
2543         rc = generic_file_mmap(file, vma);
2544         if (rc == 0)
2545                 vma->vm_ops = &cifs_file_vm_ops;
2546         FreeXid(xid);
2547         return rc;
2548 }
2549
2550 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2551 {
2552         int rc, xid;
2553
2554         xid = GetXid();
2555         rc = cifs_revalidate_file(file);
2556         if (rc) {
2557                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2558                 FreeXid(xid);
2559                 return rc;
2560         }
2561         rc = generic_file_mmap(file, vma);
2562         if (rc == 0)
2563                 vma->vm_ops = &cifs_file_vm_ops;
2564         FreeXid(xid);
2565         return rc;
2566 }
2567
2568 static int cifs_readpages(struct file *file, struct address_space *mapping,
2569         struct list_head *page_list, unsigned num_pages)
2570 {
2571         int rc;
2572         struct list_head tmplist;
2573         struct cifsFileInfo *open_file = file->private_data;
2574         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2575         unsigned int rsize = cifs_sb->rsize;
2576         pid_t pid;
2577
2578         /*
2579          * Give up immediately if rsize is too small to read an entire page.
2580          * The VFS will fall back to readpage. We should never reach this
2581          * point however since we set ra_pages to 0 when the rsize is smaller
2582          * than a cache page.
2583          */
2584         if (unlikely(rsize < PAGE_CACHE_SIZE))
2585                 return 0;
2586
2587         /*
2588          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2589          * immediately if the cookie is negative
2590          */
2591         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2592                                          &num_pages);
2593         if (rc == 0)
2594                 return rc;
2595
2596         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2597                 pid = open_file->pid;
2598         else
2599                 pid = current->tgid;
2600
2601         rc = 0;
2602         INIT_LIST_HEAD(&tmplist);
2603
2604         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2605                 mapping, num_pages);
2606
2607         /*
2608          * Start with the page at end of list and move it to private
2609          * list. Do the same with any following pages until we hit
2610          * the rsize limit, hit an index discontinuity, or run out of
2611          * pages. Issue the async read and then start the loop again
2612          * until the list is empty.
2613          *
2614          * Note that list order is important. The page_list is in
2615          * the order of declining indexes. When we put the pages in
2616          * the rdata->pages, then we want them in increasing order.
2617          */
2618         while (!list_empty(page_list)) {
2619                 unsigned int bytes = PAGE_CACHE_SIZE;
2620                 unsigned int expected_index;
2621                 unsigned int nr_pages = 1;
2622                 loff_t offset;
2623                 struct page *page, *tpage;
2624                 struct cifs_readdata *rdata;
2625
2626                 page = list_entry(page_list->prev, struct page, lru);
2627
2628                 /*
2629                  * Lock the page and put it in the cache. Since no one else
2630                  * should have access to this page, we're safe to simply set
2631                  * PG_locked without checking it first.
2632                  */
2633                 __set_page_locked(page);
2634                 rc = add_to_page_cache_locked(page, mapping,
2635                                               page->index, GFP_KERNEL);
2636
2637                 /* give up if we can't stick it in the cache */
2638                 if (rc) {
2639                         __clear_page_locked(page);
2640                         break;
2641                 }
2642
2643                 /* move first page to the tmplist */
2644                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2645                 list_move_tail(&page->lru, &tmplist);
2646
2647                 /* now try and add more pages onto the request */
2648                 expected_index = page->index + 1;
2649                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2650                         /* discontinuity ? */
2651                         if (page->index != expected_index)
2652                                 break;
2653
2654                         /* would this page push the read over the rsize? */
2655                         if (bytes + PAGE_CACHE_SIZE > rsize)
2656                                 break;
2657
2658                         __set_page_locked(page);
2659                         if (add_to_page_cache_locked(page, mapping,
2660                                                 page->index, GFP_KERNEL)) {
2661                                 __clear_page_locked(page);
2662                                 break;
2663                         }
2664                         list_move_tail(&page->lru, &tmplist);
2665                         bytes += PAGE_CACHE_SIZE;
2666                         expected_index++;
2667                         nr_pages++;
2668                 }
2669
2670                 rdata = cifs_readdata_alloc(nr_pages);
2671                 if (!rdata) {
2672                         /* best to give up if we're out of mem */
2673                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2674                                 list_del(&page->lru);
2675                                 lru_cache_add_file(page);
2676                                 unlock_page(page);
2677                                 page_cache_release(page);
2678                         }
2679                         rc = -ENOMEM;
2680                         break;
2681                 }
2682
2683                 spin_lock(&cifs_file_list_lock);
2684                 cifsFileInfo_get(open_file);
2685                 spin_unlock(&cifs_file_list_lock);
2686                 rdata->cfile = open_file;
2687                 rdata->mapping = mapping;
2688                 rdata->offset = offset;
2689                 rdata->bytes = bytes;
2690                 rdata->pid = pid;
2691                 list_splice_init(&tmplist, &rdata->pages);
2692
2693                 do {
2694                         if (open_file->invalidHandle) {
2695                                 rc = cifs_reopen_file(open_file, true);
2696                                 if (rc != 0)
2697                                         continue;
2698                         }
2699                         rc = cifs_async_readv(rdata);
2700                 } while (rc == -EAGAIN);
2701
2702                 if (rc != 0) {
2703                         list_for_each_entry_safe(page, tpage, &rdata->pages,
2704                                                  lru) {
2705                                 list_del(&page->lru);
2706                                 lru_cache_add_file(page);
2707                                 unlock_page(page);
2708                                 page_cache_release(page);
2709                         }
2710                         cifs_readdata_free(rdata);
2711                         break;
2712                 }
2713         }
2714
2715         return rc;
2716 }
2717
2718 static int cifs_readpage_worker(struct file *file, struct page *page,
2719         loff_t *poffset)
2720 {
2721         char *read_data;
2722         int rc;
2723
2724         /* Is the page cached? */
2725         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2726         if (rc == 0)
2727                 goto read_complete;
2728
2729         page_cache_get(page);
2730         read_data = kmap(page);
2731         /* for reads over a certain size could initiate async read ahead */
2732
2733         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2734
2735         if (rc < 0)
2736                 goto io_error;
2737         else
2738                 cFYI(1, "Bytes read %d", rc);
2739
2740         file->f_path.dentry->d_inode->i_atime =
2741                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2742
2743         if (PAGE_CACHE_SIZE > rc)
2744                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2745
2746         flush_dcache_page(page);
2747         SetPageUptodate(page);
2748
2749         /* send this page to the cache */
2750         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2751
2752         rc = 0;
2753
2754 io_error:
2755         kunmap(page);
2756         page_cache_release(page);
2757
2758 read_complete:
2759         return rc;
2760 }
2761
2762 static int cifs_readpage(struct file *file, struct page *page)
2763 {
2764         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2765         int rc = -EACCES;
2766         int xid;
2767
2768         xid = GetXid();
2769
2770         if (file->private_data == NULL) {
2771                 rc = -EBADF;
2772                 FreeXid(xid);
2773                 return rc;
2774         }
2775
2776         cFYI(1, "readpage %p at offset %d 0x%x\n",
2777                  page, (int)offset, (int)offset);
2778
2779         rc = cifs_readpage_worker(file, page, &offset);
2780
2781         unlock_page(page);
2782
2783         FreeXid(xid);
2784         return rc;
2785 }
2786
2787 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2788 {
2789         struct cifsFileInfo *open_file;
2790
2791         spin_lock(&cifs_file_list_lock);
2792         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2793                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2794                         spin_unlock(&cifs_file_list_lock);
2795                         return 1;
2796                 }
2797         }
2798         spin_unlock(&cifs_file_list_lock);
2799         return 0;
2800 }
2801
2802 /* We do not want to update the file size from server for inodes
2803    open for write - to avoid races with writepage extending
2804    the file - in the future we could consider allowing
2805    refreshing the inode only on increases in the file size
2806    but this is tricky to do without racing with writebehind
2807    page caching in the current Linux kernel design */
2808 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2809 {
2810         if (!cifsInode)
2811                 return true;
2812
2813         if (is_inode_writable(cifsInode)) {
2814                 /* This inode is open for write at least once */
2815                 struct cifs_sb_info *cifs_sb;
2816
2817                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2818                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2819                         /* since no page cache to corrupt on directio
2820                         we can change size safely */
2821                         return true;
2822                 }
2823
2824                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2825                         return true;
2826
2827                 return false;
2828         } else
2829                 return true;
2830 }
2831
2832 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2833                         loff_t pos, unsigned len, unsigned flags,
2834                         struct page **pagep, void **fsdata)
2835 {
2836         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2837         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2838         loff_t page_start = pos & PAGE_MASK;
2839         loff_t i_size;
2840         struct page *page;
2841         int rc = 0;
2842
2843         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2844
2845         page = grab_cache_page_write_begin(mapping, index, flags);
2846         if (!page) {
2847                 rc = -ENOMEM;
2848                 goto out;
2849         }
2850
2851         if (PageUptodate(page))
2852                 goto out;
2853
2854         /*
2855          * If we write a full page it will be up to date, no need to read from
2856          * the server. If the write is short, we'll end up doing a sync write
2857          * instead.
2858          */
2859         if (len == PAGE_CACHE_SIZE)
2860                 goto out;
2861
2862         /*
2863          * optimize away the read when we have an oplock, and we're not
2864          * expecting to use any of the data we'd be reading in. That
2865          * is, when the page lies beyond the EOF, or straddles the EOF
2866          * and the write will cover all of the existing data.
2867          */
2868         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2869                 i_size = i_size_read(mapping->host);
2870                 if (page_start >= i_size ||
2871                     (offset == 0 && (pos + len) >= i_size)) {
2872                         zero_user_segments(page, 0, offset,
2873                                            offset + len,
2874                                            PAGE_CACHE_SIZE);
2875                         /*
2876                          * PageChecked means that the parts of the page
2877                          * to which we're not writing are considered up
2878                          * to date. Once the data is copied to the
2879                          * page, it can be set uptodate.
2880                          */
2881                         SetPageChecked(page);
2882                         goto out;
2883                 }
2884         }
2885
2886         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2887                 /*
2888                  * might as well read a page, it is fast enough. If we get
2889                  * an error, we don't need to return it. cifs_write_end will
2890                  * do a sync write instead since PG_uptodate isn't set.
2891                  */
2892                 cifs_readpage_worker(file, page, &page_start);
2893         } else {
2894                 /* we could try using another file handle if there is one -
2895                    but how would we lock it to prevent close of that handle
2896                    racing with this read? In any case
2897                    this will be written out by write_end so is fine */
2898         }
2899 out:
2900         *pagep = page;
2901         return rc;
2902 }
2903
2904 static int cifs_release_page(struct page *page, gfp_t gfp)
2905 {
2906         if (PagePrivate(page))
2907                 return 0;
2908
2909         return cifs_fscache_release_page(page, gfp);
2910 }
2911
2912 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2913 {
2914         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2915
2916         if (offset == 0)
2917                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2918 }
2919
2920 static int cifs_launder_page(struct page *page)
2921 {
2922         int rc = 0;
2923         loff_t range_start = page_offset(page);
2924         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2925         struct writeback_control wbc = {
2926                 .sync_mode = WB_SYNC_ALL,
2927                 .nr_to_write = 0,
2928                 .range_start = range_start,
2929                 .range_end = range_end,
2930         };
2931
2932         cFYI(1, "Launder page: %p", page);
2933
2934         if (clear_page_dirty_for_io(page))
2935                 rc = cifs_writepage_locked(page, &wbc);
2936
2937         cifs_fscache_invalidate_page(page, page->mapping->host);
2938         return rc;
2939 }
2940
2941 void cifs_oplock_break(struct work_struct *work)
2942 {
2943         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2944                                                   oplock_break);
2945         struct inode *inode = cfile->dentry->d_inode;
2946         struct cifsInodeInfo *cinode = CIFS_I(inode);
2947         int rc = 0;
2948
2949         if (inode && S_ISREG(inode->i_mode)) {
2950                 if (cinode->clientCanCacheRead)
2951                         break_lease(inode, O_RDONLY);
2952                 else
2953                         break_lease(inode, O_WRONLY);
2954                 rc = filemap_fdatawrite(inode->i_mapping);
2955                 if (cinode->clientCanCacheRead == 0) {
2956                         rc = filemap_fdatawait(inode->i_mapping);
2957                         mapping_set_error(inode->i_mapping, rc);
2958                         invalidate_remote_inode(inode);
2959                 }
2960                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2961         }
2962
2963         rc = cifs_push_locks(cfile);
2964         if (rc)
2965                 cERROR(1, "Push locks rc = %d", rc);
2966
2967         /*
2968          * releasing stale oplock after recent reconnect of smb session using
2969          * a now incorrect file handle is not a data integrity issue but do
2970          * not bother sending an oplock release if session to server still is
2971          * disconnected since oplock already released by the server
2972          */
2973         if (!cfile->oplock_break_cancelled) {
2974                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2975                                  current->tgid, 0, 0, 0, 0,
2976                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
2977                                  cinode->clientCanCacheRead ? 1 : 0);
2978                 cFYI(1, "Oplock release rc = %d", rc);
2979         }
2980 }
2981
2982 const struct address_space_operations cifs_addr_ops = {
2983         .readpage = cifs_readpage,
2984         .readpages = cifs_readpages,
2985         .writepage = cifs_writepage,
2986         .writepages = cifs_writepages,
2987         .write_begin = cifs_write_begin,
2988         .write_end = cifs_write_end,
2989         .set_page_dirty = __set_page_dirty_nobuffers,
2990         .releasepage = cifs_release_page,
2991         .invalidatepage = cifs_invalidate_page,
2992         .launder_page = cifs_launder_page,
2993 };
2994
2995 /*
2996  * cifs_readpages requires the server to support a buffer large enough to
2997  * contain the header plus one complete page of data.  Otherwise, we need
2998  * to leave cifs_readpages out of the address space operations.
2999  */
3000 const struct address_space_operations cifs_addr_ops_smallbuf = {
3001         .readpage = cifs_readpage,
3002         .writepage = cifs_writepage,
3003         .writepages = cifs_writepages,
3004         .write_begin = cifs_write_begin,
3005         .write_end = cifs_write_end,
3006         .set_page_dirty = __set_page_dirty_nobuffers,
3007         .releasepage = cifs_release_page,
3008         .invalidatepage = cifs_invalidate_page,
3009         .launder_page = cifs_launder_page,
3010 };