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                         inv_file = NULL;
1612                         goto refind_writable;
1613                 }
1614         }
1615
1616         return NULL;
1617 }
1618
1619 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1620 {
1621         struct address_space *mapping = page->mapping;
1622         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1623         char *write_data;
1624         int rc = -EFAULT;
1625         int bytes_written = 0;
1626         struct inode *inode;
1627         struct cifsFileInfo *open_file;
1628
1629         if (!mapping || !mapping->host)
1630                 return -EFAULT;
1631
1632         inode = page->mapping->host;
1633
1634         offset += (loff_t)from;
1635         write_data = kmap(page);
1636         write_data += from;
1637
1638         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1639                 kunmap(page);
1640                 return -EIO;
1641         }
1642
1643         /* racing with truncate? */
1644         if (offset > mapping->host->i_size) {
1645                 kunmap(page);
1646                 return 0; /* don't care */
1647         }
1648
1649         /* check to make sure that we are not extending the file */
1650         if (mapping->host->i_size - offset < (loff_t)to)
1651                 to = (unsigned)(mapping->host->i_size - offset);
1652
1653         open_file = find_writable_file(CIFS_I(mapping->host), false);
1654         if (open_file) {
1655                 bytes_written = cifs_write(open_file, open_file->pid,
1656                                            write_data, to - from, &offset);
1657                 cifsFileInfo_put(open_file);
1658                 /* Does mm or vfs already set times? */
1659                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1660                 if ((bytes_written > 0) && (offset))
1661                         rc = 0;
1662                 else if (bytes_written < 0)
1663                         rc = bytes_written;
1664         } else {
1665                 cFYI(1, "No writeable filehandles for inode");
1666                 rc = -EIO;
1667         }
1668
1669         kunmap(page);
1670         return rc;
1671 }
1672
1673 static int cifs_writepages(struct address_space *mapping,
1674                            struct writeback_control *wbc)
1675 {
1676         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1677         bool done = false, scanned = false, range_whole = false;
1678         pgoff_t end, index;
1679         struct cifs_writedata *wdata;
1680         struct page *page;
1681         int rc = 0;
1682
1683         /*
1684          * If wsize is smaller than the page cache size, default to writing
1685          * one page at a time via cifs_writepage
1686          */
1687         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1688                 return generic_writepages(mapping, wbc);
1689
1690         if (wbc->range_cyclic) {
1691                 index = mapping->writeback_index; /* Start from prev offset */
1692                 end = -1;
1693         } else {
1694                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1695                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1696                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1697                         range_whole = true;
1698                 scanned = true;
1699         }
1700 retry:
1701         while (!done && index <= end) {
1702                 unsigned int i, nr_pages, found_pages;
1703                 pgoff_t next = 0, tofind;
1704                 struct page **pages;
1705
1706                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1707                                 end - index) + 1;
1708
1709                 wdata = cifs_writedata_alloc((unsigned int)tofind);
1710                 if (!wdata) {
1711                         rc = -ENOMEM;
1712                         break;
1713                 }
1714
1715                 /*
1716                  * find_get_pages_tag seems to return a max of 256 on each
1717                  * iteration, so we must call it several times in order to
1718                  * fill the array or the wsize is effectively limited to
1719                  * 256 * PAGE_CACHE_SIZE.
1720                  */
1721                 found_pages = 0;
1722                 pages = wdata->pages;
1723                 do {
1724                         nr_pages = find_get_pages_tag(mapping, &index,
1725                                                         PAGECACHE_TAG_DIRTY,
1726                                                         tofind, pages);
1727                         found_pages += nr_pages;
1728                         tofind -= nr_pages;
1729                         pages += nr_pages;
1730                 } while (nr_pages && tofind && index <= end);
1731
1732                 if (found_pages == 0) {
1733                         kref_put(&wdata->refcount, cifs_writedata_release);
1734                         break;
1735                 }
1736
1737                 nr_pages = 0;
1738                 for (i = 0; i < found_pages; i++) {
1739                         page = wdata->pages[i];
1740                         /*
1741                          * At this point we hold neither mapping->tree_lock nor
1742                          * lock on the page itself: the page may be truncated or
1743                          * invalidated (changing page->mapping to NULL), or even
1744                          * swizzled back from swapper_space to tmpfs file
1745                          * mapping
1746                          */
1747
1748                         if (nr_pages == 0)
1749                                 lock_page(page);
1750                         else if (!trylock_page(page))
1751                                 break;
1752
1753                         if (unlikely(page->mapping != mapping)) {
1754                                 unlock_page(page);
1755                                 break;
1756                         }
1757
1758                         if (!wbc->range_cyclic && page->index > end) {
1759                                 done = true;
1760                                 unlock_page(page);
1761                                 break;
1762                         }
1763
1764                         if (next && (page->index != next)) {
1765                                 /* Not next consecutive page */
1766                                 unlock_page(page);
1767                                 break;
1768                         }
1769
1770                         if (wbc->sync_mode != WB_SYNC_NONE)
1771                                 wait_on_page_writeback(page);
1772
1773                         if (PageWriteback(page) ||
1774                                         !clear_page_dirty_for_io(page)) {
1775                                 unlock_page(page);
1776                                 break;
1777                         }
1778
1779                         /*
1780                          * This actually clears the dirty bit in the radix tree.
1781                          * See cifs_writepage() for more commentary.
1782                          */
1783                         set_page_writeback(page);
1784
1785                         if (page_offset(page) >= mapping->host->i_size) {
1786                                 done = true;
1787                                 unlock_page(page);
1788                                 end_page_writeback(page);
1789                                 break;
1790                         }
1791
1792                         wdata->pages[i] = page;
1793                         next = page->index + 1;
1794                         ++nr_pages;
1795                 }
1796
1797                 /* reset index to refind any pages skipped */
1798                 if (nr_pages == 0)
1799                         index = wdata->pages[0]->index + 1;
1800
1801                 /* put any pages we aren't going to use */
1802                 for (i = nr_pages; i < found_pages; i++) {
1803                         page_cache_release(wdata->pages[i]);
1804                         wdata->pages[i] = NULL;
1805                 }
1806
1807                 /* nothing to write? */
1808                 if (nr_pages == 0) {
1809                         kref_put(&wdata->refcount, cifs_writedata_release);
1810                         continue;
1811                 }
1812
1813                 wdata->sync_mode = wbc->sync_mode;
1814                 wdata->nr_pages = nr_pages;
1815                 wdata->offset = page_offset(wdata->pages[0]);
1816
1817                 do {
1818                         if (wdata->cfile != NULL)
1819                                 cifsFileInfo_put(wdata->cfile);
1820                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1821                                                           false);
1822                         if (!wdata->cfile) {
1823                                 cERROR(1, "No writable handles for inode");
1824                                 rc = -EBADF;
1825                                 break;
1826                         }
1827                         rc = cifs_async_writev(wdata);
1828                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1829
1830                 for (i = 0; i < nr_pages; ++i)
1831                         unlock_page(wdata->pages[i]);
1832
1833                 /* send failure -- clean up the mess */
1834                 if (rc != 0) {
1835                         for (i = 0; i < nr_pages; ++i) {
1836                                 if (rc == -EAGAIN)
1837                                         redirty_page_for_writepage(wbc,
1838                                                            wdata->pages[i]);
1839                                 else
1840                                         SetPageError(wdata->pages[i]);
1841                                 end_page_writeback(wdata->pages[i]);
1842                                 page_cache_release(wdata->pages[i]);
1843                         }
1844                         if (rc != -EAGAIN)
1845                                 mapping_set_error(mapping, rc);
1846                 }
1847                 kref_put(&wdata->refcount, cifs_writedata_release);
1848
1849                 wbc->nr_to_write -= nr_pages;
1850                 if (wbc->nr_to_write <= 0)
1851                         done = true;
1852
1853                 index = next;
1854         }
1855
1856         if (!scanned && !done) {
1857                 /*
1858                  * We hit the last page and there is more work to be done: wrap
1859                  * back to the start of the file
1860                  */
1861                 scanned = true;
1862                 index = 0;
1863                 goto retry;
1864         }
1865
1866         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1867                 mapping->writeback_index = index;
1868
1869         return rc;
1870 }
1871
1872 static int
1873 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1874 {
1875         int rc;
1876         int xid;
1877
1878         xid = GetXid();
1879 /* BB add check for wbc flags */
1880         page_cache_get(page);
1881         if (!PageUptodate(page))
1882                 cFYI(1, "ppw - page not up to date");
1883
1884         /*
1885          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1886          *
1887          * A writepage() implementation always needs to do either this,
1888          * or re-dirty the page with "redirty_page_for_writepage()" in
1889          * the case of a failure.
1890          *
1891          * Just unlocking the page will cause the radix tree tag-bits
1892          * to fail to update with the state of the page correctly.
1893          */
1894         set_page_writeback(page);
1895 retry_write:
1896         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1897         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1898                 goto retry_write;
1899         else if (rc == -EAGAIN)
1900                 redirty_page_for_writepage(wbc, page);
1901         else if (rc != 0)
1902                 SetPageError(page);
1903         else
1904                 SetPageUptodate(page);
1905         end_page_writeback(page);
1906         page_cache_release(page);
1907         FreeXid(xid);
1908         return rc;
1909 }
1910
1911 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1912 {
1913         int rc = cifs_writepage_locked(page, wbc);
1914         unlock_page(page);
1915         return rc;
1916 }
1917
1918 static int cifs_write_end(struct file *file, struct address_space *mapping,
1919                         loff_t pos, unsigned len, unsigned copied,
1920                         struct page *page, void *fsdata)
1921 {
1922         int rc;
1923         struct inode *inode = mapping->host;
1924         struct cifsFileInfo *cfile = file->private_data;
1925         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1926         __u32 pid;
1927
1928         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1929                 pid = cfile->pid;
1930         else
1931                 pid = current->tgid;
1932
1933         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1934                  page, pos, copied);
1935
1936         if (PageChecked(page)) {
1937                 if (copied == len)
1938                         SetPageUptodate(page);
1939                 ClearPageChecked(page);
1940         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1941                 SetPageUptodate(page);
1942
1943         if (!PageUptodate(page)) {
1944                 char *page_data;
1945                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1946                 int xid;
1947
1948                 xid = GetXid();
1949                 /* this is probably better than directly calling
1950                    partialpage_write since in this function the file handle is
1951                    known which we might as well leverage */
1952                 /* BB check if anything else missing out of ppw
1953                    such as updating last write time */
1954                 page_data = kmap(page);
1955                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1956                 /* if (rc < 0) should we set writebehind rc? */
1957                 kunmap(page);
1958
1959                 FreeXid(xid);
1960         } else {
1961                 rc = copied;
1962                 pos += copied;
1963                 set_page_dirty(page);
1964         }
1965
1966         if (rc > 0) {
1967                 spin_lock(&inode->i_lock);
1968                 if (pos > inode->i_size)
1969                         i_size_write(inode, pos);
1970                 spin_unlock(&inode->i_lock);
1971         }
1972
1973         unlock_page(page);
1974         page_cache_release(page);
1975
1976         return rc;
1977 }
1978
1979 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1980                       int datasync)
1981 {
1982         int xid;
1983         int rc = 0;
1984         struct cifs_tcon *tcon;
1985         struct cifsFileInfo *smbfile = file->private_data;
1986         struct inode *inode = file->f_path.dentry->d_inode;
1987         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1988
1989         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1990         if (rc)
1991                 return rc;
1992         mutex_lock(&inode->i_mutex);
1993
1994         xid = GetXid();
1995
1996         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1997                 file->f_path.dentry->d_name.name, datasync);
1998
1999         if (!CIFS_I(inode)->clientCanCacheRead) {
2000                 rc = cifs_invalidate_mapping(inode);
2001                 if (rc) {
2002                         cFYI(1, "rc: %d during invalidate phase", rc);
2003                         rc = 0; /* don't care about it in fsync */
2004                 }
2005         }
2006
2007         tcon = tlink_tcon(smbfile->tlink);
2008         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2009                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2010
2011         FreeXid(xid);
2012         mutex_unlock(&inode->i_mutex);
2013         return rc;
2014 }
2015
2016 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2017 {
2018         int xid;
2019         int rc = 0;
2020         struct cifs_tcon *tcon;
2021         struct cifsFileInfo *smbfile = file->private_data;
2022         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2023         struct inode *inode = file->f_mapping->host;
2024
2025         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2026         if (rc)
2027                 return rc;
2028         mutex_lock(&inode->i_mutex);
2029
2030         xid = GetXid();
2031
2032         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2033                 file->f_path.dentry->d_name.name, datasync);
2034
2035         tcon = tlink_tcon(smbfile->tlink);
2036         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2037                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2038
2039         FreeXid(xid);
2040         mutex_unlock(&inode->i_mutex);
2041         return rc;
2042 }
2043
2044 /*
2045  * As file closes, flush all cached write data for this inode checking
2046  * for write behind errors.
2047  */
2048 int cifs_flush(struct file *file, fl_owner_t id)
2049 {
2050         struct inode *inode = file->f_path.dentry->d_inode;
2051         int rc = 0;
2052
2053         if (file->f_mode & FMODE_WRITE)
2054                 rc = filemap_write_and_wait(inode->i_mapping);
2055
2056         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2057
2058         return rc;
2059 }
2060
2061 static int
2062 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2063 {
2064         int rc = 0;
2065         unsigned long i;
2066
2067         for (i = 0; i < num_pages; i++) {
2068                 pages[i] = alloc_page(__GFP_HIGHMEM);
2069                 if (!pages[i]) {
2070                         /*
2071                          * save number of pages we have already allocated and
2072                          * return with ENOMEM error
2073                          */
2074                         num_pages = i;
2075                         rc = -ENOMEM;
2076                         goto error;
2077                 }
2078         }
2079
2080         return rc;
2081
2082 error:
2083         for (i = 0; i < num_pages; i++)
2084                 put_page(pages[i]);
2085         return rc;
2086 }
2087
2088 static inline
2089 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2090 {
2091         size_t num_pages;
2092         size_t clen;
2093
2094         clen = min_t(const size_t, len, wsize);
2095         num_pages = clen / PAGE_CACHE_SIZE;
2096         if (clen % PAGE_CACHE_SIZE)
2097                 num_pages++;
2098
2099         if (cur_len)
2100                 *cur_len = clen;
2101
2102         return num_pages;
2103 }
2104
2105 static ssize_t
2106 cifs_iovec_write(struct file *file, const struct iovec *iov,
2107                  unsigned long nr_segs, loff_t *poffset)
2108 {
2109         unsigned int written;
2110         unsigned long num_pages, npages, i;
2111         size_t bytes, copied, len, cur_len;
2112         ssize_t total_written = 0;
2113         struct kvec *to_send;
2114         struct page **pages;
2115         struct iov_iter it;
2116         struct inode *inode;
2117         struct cifsFileInfo *open_file;
2118         struct cifs_tcon *pTcon;
2119         struct cifs_sb_info *cifs_sb;
2120         struct cifs_io_parms io_parms;
2121         int xid, rc;
2122         __u32 pid;
2123
2124         len = iov_length(iov, nr_segs);
2125         if (!len)
2126                 return 0;
2127
2128         rc = generic_write_checks(file, poffset, &len, 0);
2129         if (rc)
2130                 return rc;
2131
2132         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2133         num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2134
2135         pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2136         if (!pages)
2137                 return -ENOMEM;
2138
2139         to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2140         if (!to_send) {
2141                 kfree(pages);
2142                 return -ENOMEM;
2143         }
2144
2145         rc = cifs_write_allocate_pages(pages, num_pages);
2146         if (rc) {
2147                 kfree(pages);
2148                 kfree(to_send);
2149                 return rc;
2150         }
2151
2152         xid = GetXid();
2153         open_file = file->private_data;
2154
2155         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2156                 pid = open_file->pid;
2157         else
2158                 pid = current->tgid;
2159
2160         pTcon = tlink_tcon(open_file->tlink);
2161         inode = file->f_path.dentry->d_inode;
2162
2163         iov_iter_init(&it, iov, nr_segs, len, 0);
2164         npages = num_pages;
2165
2166         do {
2167                 size_t save_len = cur_len;
2168                 for (i = 0; i < npages; i++) {
2169                         bytes = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2170                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
2171                                                          bytes);
2172                         cur_len -= copied;
2173                         iov_iter_advance(&it, copied);
2174                         to_send[i+1].iov_base = kmap(pages[i]);
2175                         to_send[i+1].iov_len = copied;
2176                         /*
2177                          * If we didn't copy as much as we expected, then that
2178                          * may mean we trod into an unmapped area. Stop copying
2179                          * at that point. On the next pass through the big
2180                          * loop, we'll likely end up getting a zero-length
2181                          * write and bailing out of it.
2182                          */
2183                         if (copied < bytes)
2184                                 break;
2185                 }
2186
2187                 cur_len = save_len - cur_len;
2188
2189                 /*
2190                  * If we have no data to send, then that probably means that
2191                  * the copy above failed altogether. That's most likely because
2192                  * the address in the iovec was bogus. Set the rc to -EFAULT,
2193                  * free anything we allocated and bail out.
2194                  */
2195                 if (!cur_len) {
2196                         kunmap(pages[0]);
2197                         if (!total_written)
2198                                 total_written = -EFAULT;
2199                         break;
2200                 }
2201
2202                 /*
2203                  * i + 1 now represents the number of pages we actually used in
2204                  * the copy phase above.
2205                  */
2206                 npages = min(npages, i + 1);
2207
2208                 do {
2209                         if (open_file->invalidHandle) {
2210                                 rc = cifs_reopen_file(open_file, false);
2211                                 if (rc != 0)
2212                                         break;
2213                         }
2214                         io_parms.netfid = open_file->netfid;
2215                         io_parms.pid = pid;
2216                         io_parms.tcon = pTcon;
2217                         io_parms.offset = *poffset;
2218                         io_parms.length = cur_len;
2219                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2220                                            npages, 0);
2221                 } while (rc == -EAGAIN);
2222
2223                 for (i = 0; i < npages; i++)
2224                         kunmap(pages[i]);
2225
2226                 if (written) {
2227                         len -= written;
2228                         total_written += written;
2229                         cifs_update_eof(CIFS_I(inode), *poffset, written);
2230                         *poffset += written;
2231                 } else if (rc < 0) {
2232                         if (!total_written)
2233                                 total_written = rc;
2234                         break;
2235                 }
2236
2237                 /* get length and number of kvecs of the next write */
2238                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2239         } while (len > 0);
2240
2241         if (total_written > 0) {
2242                 spin_lock(&inode->i_lock);
2243                 if (*poffset > inode->i_size)
2244                         i_size_write(inode, *poffset);
2245                 spin_unlock(&inode->i_lock);
2246         }
2247
2248         cifs_stats_bytes_written(pTcon, total_written);
2249         mark_inode_dirty_sync(inode);
2250
2251         for (i = 0; i < num_pages; i++)
2252                 put_page(pages[i]);
2253         kfree(to_send);
2254         kfree(pages);
2255         FreeXid(xid);
2256         return total_written;
2257 }
2258
2259 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2260                                 unsigned long nr_segs, loff_t pos)
2261 {
2262         ssize_t written;
2263         struct inode *inode;
2264
2265         inode = iocb->ki_filp->f_path.dentry->d_inode;
2266
2267         /*
2268          * BB - optimize the way when signing is disabled. We can drop this
2269          * extra memory-to-memory copying and use iovec buffers for constructing
2270          * write request.
2271          */
2272
2273         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2274         if (written > 0) {
2275                 CIFS_I(inode)->invalid_mapping = true;
2276                 iocb->ki_pos = pos;
2277         }
2278
2279         return written;
2280 }
2281
2282 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2283                            unsigned long nr_segs, loff_t pos)
2284 {
2285         struct inode *inode;
2286
2287         inode = iocb->ki_filp->f_path.dentry->d_inode;
2288
2289         if (CIFS_I(inode)->clientCanCacheAll)
2290                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2291
2292         /*
2293          * In strict cache mode we need to write the data to the server exactly
2294          * from the pos to pos+len-1 rather than flush all affected pages
2295          * because it may cause a error with mandatory locks on these pages but
2296          * not on the region from pos to ppos+len-1.
2297          */
2298
2299         return cifs_user_writev(iocb, iov, nr_segs, pos);
2300 }
2301
2302 static ssize_t
2303 cifs_iovec_read(struct file *file, const struct iovec *iov,
2304                  unsigned long nr_segs, loff_t *poffset)
2305 {
2306         int rc;
2307         int xid;
2308         ssize_t total_read;
2309         unsigned int bytes_read = 0;
2310         size_t len, cur_len;
2311         int iov_offset = 0;
2312         struct cifs_sb_info *cifs_sb;
2313         struct cifs_tcon *pTcon;
2314         struct cifsFileInfo *open_file;
2315         struct smb_com_read_rsp *pSMBr;
2316         struct cifs_io_parms io_parms;
2317         char *read_data;
2318         unsigned int rsize;
2319         __u32 pid;
2320
2321         if (!nr_segs)
2322                 return 0;
2323
2324         len = iov_length(iov, nr_segs);
2325         if (!len)
2326                 return 0;
2327
2328         xid = GetXid();
2329         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2330
2331         /* FIXME: set up handlers for larger reads and/or convert to async */
2332         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2333
2334         open_file = file->private_data;
2335         pTcon = tlink_tcon(open_file->tlink);
2336
2337         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2338                 pid = open_file->pid;
2339         else
2340                 pid = current->tgid;
2341
2342         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2343                 cFYI(1, "attempting read on write only file instance");
2344
2345         for (total_read = 0; total_read < len; total_read += bytes_read) {
2346                 cur_len = min_t(const size_t, len - total_read, rsize);
2347                 rc = -EAGAIN;
2348                 read_data = NULL;
2349
2350                 while (rc == -EAGAIN) {
2351                         int buf_type = CIFS_NO_BUFFER;
2352                         if (open_file->invalidHandle) {
2353                                 rc = cifs_reopen_file(open_file, true);
2354                                 if (rc != 0)
2355                                         break;
2356                         }
2357                         io_parms.netfid = open_file->netfid;
2358                         io_parms.pid = pid;
2359                         io_parms.tcon = pTcon;
2360                         io_parms.offset = *poffset;
2361                         io_parms.length = cur_len;
2362                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2363                                          &read_data, &buf_type);
2364                         pSMBr = (struct smb_com_read_rsp *)read_data;
2365                         if (read_data) {
2366                                 char *data_offset = read_data + 4 +
2367                                                 le16_to_cpu(pSMBr->DataOffset);
2368                                 if (memcpy_toiovecend(iov, data_offset,
2369                                                       iov_offset, bytes_read))
2370                                         rc = -EFAULT;
2371                                 if (buf_type == CIFS_SMALL_BUFFER)
2372                                         cifs_small_buf_release(read_data);
2373                                 else if (buf_type == CIFS_LARGE_BUFFER)
2374                                         cifs_buf_release(read_data);
2375                                 read_data = NULL;
2376                                 iov_offset += bytes_read;
2377                         }
2378                 }
2379
2380                 if (rc || (bytes_read == 0)) {
2381                         if (total_read) {
2382                                 break;
2383                         } else {
2384                                 FreeXid(xid);
2385                                 return rc;
2386                         }
2387                 } else {
2388                         cifs_stats_bytes_read(pTcon, bytes_read);
2389                         *poffset += bytes_read;
2390                 }
2391         }
2392
2393         FreeXid(xid);
2394         return total_read;
2395 }
2396
2397 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2398                                unsigned long nr_segs, loff_t pos)
2399 {
2400         ssize_t read;
2401
2402         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2403         if (read > 0)
2404                 iocb->ki_pos = pos;
2405
2406         return read;
2407 }
2408
2409 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2410                           unsigned long nr_segs, loff_t pos)
2411 {
2412         struct inode *inode;
2413
2414         inode = iocb->ki_filp->f_path.dentry->d_inode;
2415
2416         if (CIFS_I(inode)->clientCanCacheRead)
2417                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2418
2419         /*
2420          * In strict cache mode we need to read from the server all the time
2421          * if we don't have level II oplock because the server can delay mtime
2422          * change - so we can't make a decision about inode invalidating.
2423          * And we can also fail with pagereading if there are mandatory locks
2424          * on pages affected by this read but not on the region from pos to
2425          * pos+len-1.
2426          */
2427
2428         return cifs_user_readv(iocb, iov, nr_segs, pos);
2429 }
2430
2431 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2432                          loff_t *poffset)
2433 {
2434         int rc = -EACCES;
2435         unsigned int bytes_read = 0;
2436         unsigned int total_read;
2437         unsigned int current_read_size;
2438         unsigned int rsize;
2439         struct cifs_sb_info *cifs_sb;
2440         struct cifs_tcon *pTcon;
2441         int xid;
2442         char *current_offset;
2443         struct cifsFileInfo *open_file;
2444         struct cifs_io_parms io_parms;
2445         int buf_type = CIFS_NO_BUFFER;
2446         __u32 pid;
2447
2448         xid = GetXid();
2449         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2450
2451         /* FIXME: set up handlers for larger reads and/or convert to async */
2452         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2453
2454         if (file->private_data == NULL) {
2455                 rc = -EBADF;
2456                 FreeXid(xid);
2457                 return rc;
2458         }
2459         open_file = file->private_data;
2460         pTcon = tlink_tcon(open_file->tlink);
2461
2462         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2463                 pid = open_file->pid;
2464         else
2465                 pid = current->tgid;
2466
2467         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2468                 cFYI(1, "attempting read on write only file instance");
2469
2470         for (total_read = 0, current_offset = read_data;
2471              read_size > total_read;
2472              total_read += bytes_read, current_offset += bytes_read) {
2473                 current_read_size = min_t(uint, read_size - total_read, rsize);
2474
2475                 /* For windows me and 9x we do not want to request more
2476                 than it negotiated since it will refuse the read then */
2477                 if ((pTcon->ses) &&
2478                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2479                         current_read_size = min_t(uint, current_read_size,
2480                                         CIFSMaxBufSize);
2481                 }
2482                 rc = -EAGAIN;
2483                 while (rc == -EAGAIN) {
2484                         if (open_file->invalidHandle) {
2485                                 rc = cifs_reopen_file(open_file, true);
2486                                 if (rc != 0)
2487                                         break;
2488                         }
2489                         io_parms.netfid = open_file->netfid;
2490                         io_parms.pid = pid;
2491                         io_parms.tcon = pTcon;
2492                         io_parms.offset = *poffset;
2493                         io_parms.length = current_read_size;
2494                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2495                                          &current_offset, &buf_type);
2496                 }
2497                 if (rc || (bytes_read == 0)) {
2498                         if (total_read) {
2499                                 break;
2500                         } else {
2501                                 FreeXid(xid);
2502                                 return rc;
2503                         }
2504                 } else {
2505                         cifs_stats_bytes_read(pTcon, total_read);
2506                         *poffset += bytes_read;
2507                 }
2508         }
2509         FreeXid(xid);
2510         return total_read;
2511 }
2512
2513 /*
2514  * If the page is mmap'ed into a process' page tables, then we need to make
2515  * sure that it doesn't change while being written back.
2516  */
2517 static int
2518 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2519 {
2520         struct page *page = vmf->page;
2521
2522         lock_page(page);
2523         return VM_FAULT_LOCKED;
2524 }
2525
2526 static struct vm_operations_struct cifs_file_vm_ops = {
2527         .fault = filemap_fault,
2528         .page_mkwrite = cifs_page_mkwrite,
2529 };
2530
2531 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2532 {
2533         int rc, xid;
2534         struct inode *inode = file->f_path.dentry->d_inode;
2535
2536         xid = GetXid();
2537
2538         if (!CIFS_I(inode)->clientCanCacheRead) {
2539                 rc = cifs_invalidate_mapping(inode);
2540                 if (rc)
2541                         return rc;
2542         }
2543
2544         rc = generic_file_mmap(file, vma);
2545         if (rc == 0)
2546                 vma->vm_ops = &cifs_file_vm_ops;
2547         FreeXid(xid);
2548         return rc;
2549 }
2550
2551 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2552 {
2553         int rc, xid;
2554
2555         xid = GetXid();
2556         rc = cifs_revalidate_file(file);
2557         if (rc) {
2558                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2559                 FreeXid(xid);
2560                 return rc;
2561         }
2562         rc = generic_file_mmap(file, vma);
2563         if (rc == 0)
2564                 vma->vm_ops = &cifs_file_vm_ops;
2565         FreeXid(xid);
2566         return rc;
2567 }
2568
2569 static int cifs_readpages(struct file *file, struct address_space *mapping,
2570         struct list_head *page_list, unsigned num_pages)
2571 {
2572         int rc;
2573         struct list_head tmplist;
2574         struct cifsFileInfo *open_file = file->private_data;
2575         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2576         unsigned int rsize = cifs_sb->rsize;
2577         pid_t pid;
2578
2579         /*
2580          * Give up immediately if rsize is too small to read an entire page.
2581          * The VFS will fall back to readpage. We should never reach this
2582          * point however since we set ra_pages to 0 when the rsize is smaller
2583          * than a cache page.
2584          */
2585         if (unlikely(rsize < PAGE_CACHE_SIZE))
2586                 return 0;
2587
2588         /*
2589          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2590          * immediately if the cookie is negative
2591          */
2592         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2593                                          &num_pages);
2594         if (rc == 0)
2595                 return rc;
2596
2597         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2598                 pid = open_file->pid;
2599         else
2600                 pid = current->tgid;
2601
2602         rc = 0;
2603         INIT_LIST_HEAD(&tmplist);
2604
2605         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2606                 mapping, num_pages);
2607
2608         /*
2609          * Start with the page at end of list and move it to private
2610          * list. Do the same with any following pages until we hit
2611          * the rsize limit, hit an index discontinuity, or run out of
2612          * pages. Issue the async read and then start the loop again
2613          * until the list is empty.
2614          *
2615          * Note that list order is important. The page_list is in
2616          * the order of declining indexes. When we put the pages in
2617          * the rdata->pages, then we want them in increasing order.
2618          */
2619         while (!list_empty(page_list)) {
2620                 unsigned int bytes = PAGE_CACHE_SIZE;
2621                 unsigned int expected_index;
2622                 unsigned int nr_pages = 1;
2623                 loff_t offset;
2624                 struct page *page, *tpage;
2625                 struct cifs_readdata *rdata;
2626
2627                 page = list_entry(page_list->prev, struct page, lru);
2628
2629                 /*
2630                  * Lock the page and put it in the cache. Since no one else
2631                  * should have access to this page, we're safe to simply set
2632                  * PG_locked without checking it first.
2633                  */
2634                 __set_page_locked(page);
2635                 rc = add_to_page_cache_locked(page, mapping,
2636                                               page->index, GFP_KERNEL);
2637
2638                 /* give up if we can't stick it in the cache */
2639                 if (rc) {
2640                         __clear_page_locked(page);
2641                         break;
2642                 }
2643
2644                 /* move first page to the tmplist */
2645                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2646                 list_move_tail(&page->lru, &tmplist);
2647
2648                 /* now try and add more pages onto the request */
2649                 expected_index = page->index + 1;
2650                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2651                         /* discontinuity ? */
2652                         if (page->index != expected_index)
2653                                 break;
2654
2655                         /* would this page push the read over the rsize? */
2656                         if (bytes + PAGE_CACHE_SIZE > rsize)
2657                                 break;
2658
2659                         __set_page_locked(page);
2660                         if (add_to_page_cache_locked(page, mapping,
2661                                                 page->index, GFP_KERNEL)) {
2662                                 __clear_page_locked(page);
2663                                 break;
2664                         }
2665                         list_move_tail(&page->lru, &tmplist);
2666                         bytes += PAGE_CACHE_SIZE;
2667                         expected_index++;
2668                         nr_pages++;
2669                 }
2670
2671                 rdata = cifs_readdata_alloc(nr_pages);
2672                 if (!rdata) {
2673                         /* best to give up if we're out of mem */
2674                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2675                                 list_del(&page->lru);
2676                                 lru_cache_add_file(page);
2677                                 unlock_page(page);
2678                                 page_cache_release(page);
2679                         }
2680                         rc = -ENOMEM;
2681                         break;
2682                 }
2683
2684                 spin_lock(&cifs_file_list_lock);
2685                 cifsFileInfo_get(open_file);
2686                 spin_unlock(&cifs_file_list_lock);
2687                 rdata->cfile = open_file;
2688                 rdata->mapping = mapping;
2689                 rdata->offset = offset;
2690                 rdata->bytes = bytes;
2691                 rdata->pid = pid;
2692                 list_splice_init(&tmplist, &rdata->pages);
2693
2694                 do {
2695                         if (open_file->invalidHandle) {
2696                                 rc = cifs_reopen_file(open_file, true);
2697                                 if (rc != 0)
2698                                         continue;
2699                         }
2700                         rc = cifs_async_readv(rdata);
2701                 } while (rc == -EAGAIN);
2702
2703                 if (rc != 0) {
2704                         list_for_each_entry_safe(page, tpage, &rdata->pages,
2705                                                  lru) {
2706                                 list_del(&page->lru);
2707                                 lru_cache_add_file(page);
2708                                 unlock_page(page);
2709                                 page_cache_release(page);
2710                         }
2711                         cifs_readdata_free(rdata);
2712                         break;
2713                 }
2714         }
2715
2716         return rc;
2717 }
2718
2719 static int cifs_readpage_worker(struct file *file, struct page *page,
2720         loff_t *poffset)
2721 {
2722         char *read_data;
2723         int rc;
2724
2725         /* Is the page cached? */
2726         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2727         if (rc == 0)
2728                 goto read_complete;
2729
2730         page_cache_get(page);
2731         read_data = kmap(page);
2732         /* for reads over a certain size could initiate async read ahead */
2733
2734         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2735
2736         if (rc < 0)
2737                 goto io_error;
2738         else
2739                 cFYI(1, "Bytes read %d", rc);
2740
2741         file->f_path.dentry->d_inode->i_atime =
2742                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2743
2744         if (PAGE_CACHE_SIZE > rc)
2745                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2746
2747         flush_dcache_page(page);
2748         SetPageUptodate(page);
2749
2750         /* send this page to the cache */
2751         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2752
2753         rc = 0;
2754
2755 io_error:
2756         kunmap(page);
2757         page_cache_release(page);
2758
2759 read_complete:
2760         return rc;
2761 }
2762
2763 static int cifs_readpage(struct file *file, struct page *page)
2764 {
2765         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2766         int rc = -EACCES;
2767         int xid;
2768
2769         xid = GetXid();
2770
2771         if (file->private_data == NULL) {
2772                 rc = -EBADF;
2773                 FreeXid(xid);
2774                 return rc;
2775         }
2776
2777         cFYI(1, "readpage %p at offset %d 0x%x\n",
2778                  page, (int)offset, (int)offset);
2779
2780         rc = cifs_readpage_worker(file, page, &offset);
2781
2782         unlock_page(page);
2783
2784         FreeXid(xid);
2785         return rc;
2786 }
2787
2788 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2789 {
2790         struct cifsFileInfo *open_file;
2791
2792         spin_lock(&cifs_file_list_lock);
2793         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2794                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2795                         spin_unlock(&cifs_file_list_lock);
2796                         return 1;
2797                 }
2798         }
2799         spin_unlock(&cifs_file_list_lock);
2800         return 0;
2801 }
2802
2803 /* We do not want to update the file size from server for inodes
2804    open for write - to avoid races with writepage extending
2805    the file - in the future we could consider allowing
2806    refreshing the inode only on increases in the file size
2807    but this is tricky to do without racing with writebehind
2808    page caching in the current Linux kernel design */
2809 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2810 {
2811         if (!cifsInode)
2812                 return true;
2813
2814         if (is_inode_writable(cifsInode)) {
2815                 /* This inode is open for write at least once */
2816                 struct cifs_sb_info *cifs_sb;
2817
2818                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2819                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2820                         /* since no page cache to corrupt on directio
2821                         we can change size safely */
2822                         return true;
2823                 }
2824
2825                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2826                         return true;
2827
2828                 return false;
2829         } else
2830                 return true;
2831 }
2832
2833 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2834                         loff_t pos, unsigned len, unsigned flags,
2835                         struct page **pagep, void **fsdata)
2836 {
2837         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2838         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2839         loff_t page_start = pos & PAGE_MASK;
2840         loff_t i_size;
2841         struct page *page;
2842         int rc = 0;
2843
2844         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2845
2846         page = grab_cache_page_write_begin(mapping, index, flags);
2847         if (!page) {
2848                 rc = -ENOMEM;
2849                 goto out;
2850         }
2851
2852         if (PageUptodate(page))
2853                 goto out;
2854
2855         /*
2856          * If we write a full page it will be up to date, no need to read from
2857          * the server. If the write is short, we'll end up doing a sync write
2858          * instead.
2859          */
2860         if (len == PAGE_CACHE_SIZE)
2861                 goto out;
2862
2863         /*
2864          * optimize away the read when we have an oplock, and we're not
2865          * expecting to use any of the data we'd be reading in. That
2866          * is, when the page lies beyond the EOF, or straddles the EOF
2867          * and the write will cover all of the existing data.
2868          */
2869         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2870                 i_size = i_size_read(mapping->host);
2871                 if (page_start >= i_size ||
2872                     (offset == 0 && (pos + len) >= i_size)) {
2873                         zero_user_segments(page, 0, offset,
2874                                            offset + len,
2875                                            PAGE_CACHE_SIZE);
2876                         /*
2877                          * PageChecked means that the parts of the page
2878                          * to which we're not writing are considered up
2879                          * to date. Once the data is copied to the
2880                          * page, it can be set uptodate.
2881                          */
2882                         SetPageChecked(page);
2883                         goto out;
2884                 }
2885         }
2886
2887         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2888                 /*
2889                  * might as well read a page, it is fast enough. If we get
2890                  * an error, we don't need to return it. cifs_write_end will
2891                  * do a sync write instead since PG_uptodate isn't set.
2892                  */
2893                 cifs_readpage_worker(file, page, &page_start);
2894         } else {
2895                 /* we could try using another file handle if there is one -
2896                    but how would we lock it to prevent close of that handle
2897                    racing with this read? In any case
2898                    this will be written out by write_end so is fine */
2899         }
2900 out:
2901         *pagep = page;
2902         return rc;
2903 }
2904
2905 static int cifs_release_page(struct page *page, gfp_t gfp)
2906 {
2907         if (PagePrivate(page))
2908                 return 0;
2909
2910         return cifs_fscache_release_page(page, gfp);
2911 }
2912
2913 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2914 {
2915         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2916
2917         if (offset == 0)
2918                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2919 }
2920
2921 static int cifs_launder_page(struct page *page)
2922 {
2923         int rc = 0;
2924         loff_t range_start = page_offset(page);
2925         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2926         struct writeback_control wbc = {
2927                 .sync_mode = WB_SYNC_ALL,
2928                 .nr_to_write = 0,
2929                 .range_start = range_start,
2930                 .range_end = range_end,
2931         };
2932
2933         cFYI(1, "Launder page: %p", page);
2934
2935         if (clear_page_dirty_for_io(page))
2936                 rc = cifs_writepage_locked(page, &wbc);
2937
2938         cifs_fscache_invalidate_page(page, page->mapping->host);
2939         return rc;
2940 }
2941
2942 void cifs_oplock_break(struct work_struct *work)
2943 {
2944         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2945                                                   oplock_break);
2946         struct inode *inode = cfile->dentry->d_inode;
2947         struct cifsInodeInfo *cinode = CIFS_I(inode);
2948         int rc = 0;
2949
2950         if (inode && S_ISREG(inode->i_mode)) {
2951                 if (cinode->clientCanCacheRead)
2952                         break_lease(inode, O_RDONLY);
2953                 else
2954                         break_lease(inode, O_WRONLY);
2955                 rc = filemap_fdatawrite(inode->i_mapping);
2956                 if (cinode->clientCanCacheRead == 0) {
2957                         rc = filemap_fdatawait(inode->i_mapping);
2958                         mapping_set_error(inode->i_mapping, rc);
2959                         invalidate_remote_inode(inode);
2960                 }
2961                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2962         }
2963
2964         rc = cifs_push_locks(cfile);
2965         if (rc)
2966                 cERROR(1, "Push locks rc = %d", rc);
2967
2968         /*
2969          * releasing stale oplock after recent reconnect of smb session using
2970          * a now incorrect file handle is not a data integrity issue but do
2971          * not bother sending an oplock release if session to server still is
2972          * disconnected since oplock already released by the server
2973          */
2974         if (!cfile->oplock_break_cancelled) {
2975                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2976                                  current->tgid, 0, 0, 0, 0,
2977                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
2978                                  cinode->clientCanCacheRead ? 1 : 0);
2979                 cFYI(1, "Oplock release rc = %d", rc);
2980         }
2981 }
2982
2983 const struct address_space_operations cifs_addr_ops = {
2984         .readpage = cifs_readpage,
2985         .readpages = cifs_readpages,
2986         .writepage = cifs_writepage,
2987         .writepages = cifs_writepages,
2988         .write_begin = cifs_write_begin,
2989         .write_end = cifs_write_end,
2990         .set_page_dirty = __set_page_dirty_nobuffers,
2991         .releasepage = cifs_release_page,
2992         .invalidatepage = cifs_invalidate_page,
2993         .launder_page = cifs_launder_page,
2994 };
2995
2996 /*
2997  * cifs_readpages requires the server to support a buffer large enough to
2998  * contain the header plus one complete page of data.  Otherwise, we need
2999  * to leave cifs_readpages out of the address space operations.
3000  */
3001 const struct address_space_operations cifs_addr_ops_smallbuf = {
3002         .readpage = cifs_readpage,
3003         .writepage = cifs_writepage,
3004         .writepages = cifs_writepages,
3005         .write_begin = cifs_write_begin,
3006         .write_end = cifs_write_end,
3007         .set_page_dirty = __set_page_dirty_nobuffers,
3008         .releasepage = cifs_release_page,
3009         .invalidatepage = cifs_invalidate_page,
3010         .launder_page = cifs_launder_page,
3011 };