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 <asm/div64.h>
  36 #include "cifsfs.h"
  37 #include "cifspdu.h"
  38 #include "cifsglob.h"
  39 #include "cifsproto.h"
  40 #include "cifs_unicode.h"
  41 #include "cifs_debug.h"
  42 #include "cifs_fs_sb.h"
  43 #include "fscache.h"
  44
  45 static inline int cifs_convert_flags(unsigned int flags)
  46 {
  47         if ((flags & O_ACCMODE) == O_RDONLY)
  48                 return GENERIC_READ;
  49         else if ((flags & O_ACCMODE) == O_WRONLY)
  50                 return GENERIC_WRITE;
  51         else if ((flags & O_ACCMODE) == O_RDWR) {
  52                 /* GENERIC_ALL is too much permission to request
  53                    can cause unnecessary access denied on create */
  54                 /* return GENERIC_ALL; */
  55                 return (GENERIC_READ | GENERIC_WRITE);
  56         }
  57
  58         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  59                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  60                 FILE_READ_DATA);
  61 }
  62
  63 static u32 cifs_posix_convert_flags(unsigned int flags)
  64 {
  65         u32 posix_flags = 0;
  66
  67         if ((flags & O_ACCMODE) == O_RDONLY)
  68                 posix_flags = SMB_O_RDONLY;
  69         else if ((flags & O_ACCMODE) == O_WRONLY)
  70                 posix_flags = SMB_O_WRONLY;
  71         else if ((flags & O_ACCMODE) == O_RDWR)
  72                 posix_flags = SMB_O_RDWR;
  73
  74         if (flags & O_CREAT)
  75                 posix_flags |= SMB_O_CREAT;
  76         if (flags & O_EXCL)
  77                 posix_flags |= SMB_O_EXCL;
  78         if (flags & O_TRUNC)
  79                 posix_flags |= SMB_O_TRUNC;
  80         /* be safe and imply O_SYNC for O_DSYNC */
  81         if (flags & O_DSYNC)
  82                 posix_flags |= SMB_O_SYNC;
  83         if (flags & O_DIRECTORY)
  84                 posix_flags |= SMB_O_DIRECTORY;
  85         if (flags & O_NOFOLLOW)
  86                 posix_flags |= SMB_O_NOFOLLOW;
  87         if (flags & O_DIRECT)
  88                 posix_flags |= SMB_O_DIRECT;
  89
  90         return posix_flags;
  91 }
  92
  93 static inline int cifs_get_disposition(unsigned int flags)
  94 {
  95         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
  96                 return FILE_CREATE;
  97         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
  98                 return FILE_OVERWRITE_IF;
  99         else if ((flags & O_CREAT) == O_CREAT)
 100                 return FILE_OPEN_IF;
 101         else if ((flags & O_TRUNC) == O_TRUNC)
 102                 return FILE_OVERWRITE;
 103         else
 104                 return FILE_OPEN;
 105 }
 106
 107 static inline int cifs_open_inode_helper(struct inode *inode,
 108         struct cifsTconInfo *pTcon, __u32 oplock, FILE_ALL_INFO *buf,
 109         char *full_path, int xid)
 110 {
 111         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
 112         struct timespec temp;
 113         int rc;
 114
 115         if (pCifsInode->clientCanCacheRead) {
 116                 /* we have the inode open somewhere else
 117                    no need to discard cache data */
 118                 goto client_can_cache;
 119         }
 120
 121         /* BB need same check in cifs_create too? */
 122         /* if not oplocked, invalidate inode pages if mtime or file
 123            size changed */
 124         temp = cifs_NTtimeToUnix(buf->LastWriteTime);
 125         if (timespec_equal(&inode->i_mtime, &temp) &&
 126                            (inode->i_size ==
 127                             (loff_t)le64_to_cpu(buf->EndOfFile))) {
 128                 cFYI(1, "inode unchanged on server");
 129         } else {
 130                 if (inode->i_mapping) {
 131                         /* BB no need to lock inode until after invalidate
 132                         since namei code should already have it locked? */
 133                         rc = filemap_write_and_wait(inode->i_mapping);
 134                         mapping_set_error(inode->i_mapping, rc);
 135                 }
 136                 cFYI(1, "invalidating remote inode since open detected it "
 137                          "changed");
 138                 invalidate_remote_inode(inode);
 139         }
 140
 141 client_can_cache:
 142         if (pTcon->unix_ext)
 143                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 144                                               xid);
 145         else
 146                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 147                                          xid, NULL);
 148
 149         cifs_set_oplock_level(pCifsInode, oplock);
 150
 151         return rc;
 152 }
 153
 154 int cifs_posix_open(char *full_path, struct inode **pinode,
 155                         struct super_block *sb, int mode, unsigned int f_flags,
 156                         __u32 *poplock, __u16 *pnetfid, int xid)
 157 {
 158         int rc;
 159         FILE_UNIX_BASIC_INFO *presp_data;
 160         __u32 posix_flags = 0;
 161         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 162         struct cifs_fattr fattr;
 163         struct tcon_link *tlink;
 164         struct cifsTconInfo *tcon;
 165
 166         cFYI(1, "posix open %s", full_path);
 167
 168         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 169         if (presp_data == NULL)
 170                 return -ENOMEM;
 171
 172         tlink = cifs_sb_tlink(cifs_sb);
 173         if (IS_ERR(tlink)) {
 174                 rc = PTR_ERR(tlink);
 175                 goto posix_open_ret;
 176         }
 177
 178         tcon = tlink_tcon(tlink);
 179         mode &= ~current_umask();
 180
 181         posix_flags = cifs_posix_convert_flags(f_flags);
 182         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 183                              poplock, full_path, cifs_sb->local_nls,
 184                              cifs_sb->mnt_cifs_flags &
 185                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 186         cifs_put_tlink(tlink);
 187
 188         if (rc)
 189                 goto posix_open_ret;
 190
 191         if (presp_data->Type == cpu_to_le32(-1))
 192                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 193
 194         if (!pinode)
 195                 goto posix_open_ret; /* caller does not need info */
 196
 197         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 198
 199         /* get new inode and set it up */
 200         if (*pinode == NULL) {
 201                 cifs_fill_uniqueid(sb, &fattr);
 202                 *pinode = cifs_iget(sb, &fattr);
 203                 if (!*pinode) {
 204                         rc = -ENOMEM;
 205                         goto posix_open_ret;
 206                 }
 207         } else {
 208                 cifs_fattr_to_inode(*pinode, &fattr);
 209         }
 210
 211 posix_open_ret:
 212         kfree(presp_data);
 213         return rc;
 214 }
 215
 216 struct cifsFileInfo *
 217 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
 218                   struct tcon_link *tlink, __u32 oplock)
 219 {
 220         struct dentry *dentry = file->f_path.dentry;
 221         struct inode *inode = dentry->d_inode;
 222         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
 223         struct cifsFileInfo *pCifsFile;
 224
 225         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 226         if (pCifsFile == NULL)
 227                 return pCifsFile;
 228
 229         pCifsFile->count = 1;
 230         pCifsFile->netfid = fileHandle;
 231         pCifsFile->pid = current->tgid;
 232         pCifsFile->uid = current_fsuid();
 233         pCifsFile->dentry = dget(dentry);
 234         pCifsFile->f_flags = file->f_flags;
 235         pCifsFile->invalidHandle = false;
 236         pCifsFile->tlink = cifs_get_tlink(tlink);
 237         mutex_init(&pCifsFile->fh_mutex);
 238         mutex_init(&pCifsFile->lock_mutex);
 239         INIT_LIST_HEAD(&pCifsFile->llist);
 240         INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
 241
 242         spin_lock(&cifs_file_list_lock);
 243         list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
 244         /* if readable file instance put first in list*/
 245         if (file->f_mode & FMODE_READ)
 246                 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
 247         else
 248                 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
 249         spin_unlock(&cifs_file_list_lock);
 250
 251         cifs_set_oplock_level(pCifsInode, oplock);
 252
 253         file->private_data = pCifsFile;
 254         return pCifsFile;
 255 }
 256
 257 /*
 258  * Release a reference on the file private data. This may involve closing
 259  * the filehandle out on the server. Must be called without holding
 260  * cifs_file_list_lock.
 261  */
 262 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 263 {
 264         struct inode *inode = cifs_file->dentry->d_inode;
 265         struct cifsTconInfo *tcon = tlink_tcon(cifs_file->tlink);
 266         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 267         struct cifsLockInfo *li, *tmp;
 268
 269         spin_lock(&cifs_file_list_lock);
 270         if (--cifs_file->count > 0) {
 271                 spin_unlock(&cifs_file_list_lock);
 272                 return;
 273         }
 274
 275         /* remove it from the lists */
 276         list_del(&cifs_file->flist);
 277         list_del(&cifs_file->tlist);
 278
 279         if (list_empty(&cifsi->openFileList)) {
 280                 cFYI(1, "closing last open instance for inode %p",
 281                         cifs_file->dentry->d_inode);
 282                 cifs_set_oplock_level(cifsi, 0);
 283         }
 284         spin_unlock(&cifs_file_list_lock);
 285
 286         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 287                 int xid, rc;
 288
 289                 xid = GetXid();
 290                 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
 291                 FreeXid(xid);
 292         }
 293
 294         /* Delete any outstanding lock records. We'll lose them when the file
 295          * is closed anyway.
 296          */
 297         mutex_lock(&cifs_file->lock_mutex);
 298         list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
 299                 list_del(&li->llist);
 300                 kfree(li);
 301         }
 302         mutex_unlock(&cifs_file->lock_mutex);
 303
 304         cifs_put_tlink(cifs_file->tlink);
 305         dput(cifs_file->dentry);
 306         kfree(cifs_file);
 307 }
 308
 309 int cifs_open(struct inode *inode, struct file *file)
 310 {
 311         int rc = -EACCES;
 312         int xid;
 313         __u32 oplock;
 314         struct cifs_sb_info *cifs_sb;
 315         struct cifsTconInfo *tcon;
 316         struct tcon_link *tlink;
 317         struct cifsFileInfo *pCifsFile = NULL;
 318         struct cifsInodeInfo *pCifsInode;
 319         char *full_path = NULL;
 320         int desiredAccess;
 321         int disposition;
 322         __u16 netfid;
 323         FILE_ALL_INFO *buf = NULL;
 324
 325         xid = GetXid();
 326
 327         cifs_sb = CIFS_SB(inode->i_sb);
 328         tlink = cifs_sb_tlink(cifs_sb);
 329         if (IS_ERR(tlink)) {
 330                 FreeXid(xid);
 331                 return PTR_ERR(tlink);
 332         }
 333         tcon = tlink_tcon(tlink);
 334
 335         pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
 336
 337         full_path = build_path_from_dentry(file->f_path.dentry);
 338         if (full_path == NULL) {
 339                 rc = -ENOMEM;
 340                 goto out;
 341         }
 342
 343         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
 344                  inode, file->f_flags, full_path);
 345
 346         if (oplockEnabled)
 347                 oplock = REQ_OPLOCK;
 348         else
 349                 oplock = 0;
 350
 351         if (!tcon->broken_posix_open && tcon->unix_ext &&
 352             (tcon->ses->capabilities & CAP_UNIX) &&
 353             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 354                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 355                 /* can not refresh inode info since size could be stale */
 356                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 357                                 cifs_sb->mnt_file_mode /* ignored */,
 358                                 file->f_flags, &oplock, &netfid, xid);
 359                 if (rc == 0) {
 360                         cFYI(1, "posix open succeeded");
 361
 362                         pCifsFile = cifs_new_fileinfo(netfid, file, tlink,
 363                                                       oplock);
 364                         if (pCifsFile == NULL) {
 365                                 CIFSSMBClose(xid, tcon, netfid);
 366                                 rc = -ENOMEM;
 367                         }
 368
 369                         cifs_fscache_set_inode_cookie(inode, file);
 370
 371                         goto out;
 372                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 373                         if (tcon->ses->serverNOS)
 374                                 cERROR(1, "server %s of type %s returned"
 375                                            " unexpected error on SMB posix open"
 376                                            ", disabling posix open support."
 377                                            " Check if server update available.",
 378                                            tcon->ses->serverName,
 379                                            tcon->ses->serverNOS);
 380                         tcon->broken_posix_open = true;
 381                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 382                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 383                         goto out;
 384                 /* else fallthrough to retry open the old way on network i/o
 385                    or DFS errors */
 386         }
 387
 388         desiredAccess = cifs_convert_flags(file->f_flags);
 389
 390 /*********************************************************************
 391  *  open flag mapping table:
 392  *
 393  *      POSIX Flag            CIFS Disposition
 394  *      ----------            ----------------
 395  *      O_CREAT               FILE_OPEN_IF
 396  *      O_CREAT | O_EXCL      FILE_CREATE
 397  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 398  *      O_TRUNC               FILE_OVERWRITE
 399  *      none of the above     FILE_OPEN
 400  *
 401  *      Note that there is not a direct match between disposition
 402  *      FILE_SUPERSEDE (ie create whether or not file exists although
 403  *      O_CREAT | O_TRUNC is similar but truncates the existing
 404  *      file rather than creating a new file as FILE_SUPERSEDE does
 405  *      (which uses the attributes / metadata passed in on open call)
 406  *?
 407  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 408  *?  and the read write flags match reasonably.  O_LARGEFILE
 409  *?  is irrelevant because largefile support is always used
 410  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 411  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 412  *********************************************************************/
 413
 414         disposition = cifs_get_disposition(file->f_flags);
 415
 416         /* BB pass O_SYNC flag through on file attributes .. BB */
 417
 418         /* Also refresh inode by passing in file_info buf returned by SMBOpen
 419            and calling get_inode_info with returned buf (at least helps
 420            non-Unix server case) */
 421
 422         /* BB we can not do this if this is the second open of a file
 423            and the first handle has writebehind data, we might be
 424            able to simply do a filemap_fdatawrite/filemap_fdatawait first */
 425         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 426         if (!buf) {
 427                 rc = -ENOMEM;
 428                 goto out;
 429         }
 430
 431         if (tcon->ses->capabilities & CAP_NT_SMBS)
 432                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 433                          desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
 434                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 435                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
 436         else
 437                 rc = -EIO; /* no NT SMB support fall into legacy open below */
 438
 439         if (rc == -EIO) {
 440                 /* Old server, try legacy style OpenX */
 441                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 442                         desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
 443                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 444                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
 445         }
 446         if (rc) {
 447                 cFYI(1, "cifs_open returned 0x%x", rc);
 448                 goto out;
 449         }
 450
 451         rc = cifs_open_inode_helper(inode, tcon, oplock, buf, full_path, xid);
 452         if (rc != 0)
 453                 goto out;
 454
 455         pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
 456         if (pCifsFile == NULL) {
 457                 rc = -ENOMEM;
 458                 goto out;
 459         }
 460
 461         cifs_fscache_set_inode_cookie(inode, file);
 462
 463         if (oplock & CIFS_CREATE_ACTION) {
 464                 /* time to set mode which we can not set earlier due to
 465                    problems creating new read-only files */
 466                 if (tcon->unix_ext) {
 467                         struct cifs_unix_set_info_args args = {
 468                                 .mode   = inode->i_mode,
 469                                 .uid    = NO_CHANGE_64,
 470                                 .gid    = NO_CHANGE_64,
 471                                 .ctime  = NO_CHANGE_64,
 472                                 .atime  = NO_CHANGE_64,
 473                                 .mtime  = NO_CHANGE_64,
 474                                 .device = 0,
 475                         };
 476                         CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
 477                                                cifs_sb->local_nls,
 478                                                cifs_sb->mnt_cifs_flags &
 479                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 480                 }
 481         }
 482
 483 out:
 484         kfree(buf);
 485         kfree(full_path);
 486         FreeXid(xid);
 487         cifs_put_tlink(tlink);
 488         return rc;
 489 }
 490
 491 /* Try to reacquire byte range locks that were released when session */
 492 /* to server was lost */
 493 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
 494 {
 495         int rc = 0;
 496
 497 /* BB list all locks open on this file and relock */
 498
 499         return rc;
 500 }
 501
 502 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
 503 {
 504         int rc = -EACCES;
 505         int xid;
 506         __u32 oplock;
 507         struct cifs_sb_info *cifs_sb;
 508         struct cifsTconInfo *tcon;
 509         struct cifsInodeInfo *pCifsInode;
 510         struct inode *inode;
 511         char *full_path = NULL;
 512         int desiredAccess;
 513         int disposition = FILE_OPEN;
 514         __u16 netfid;
 515
 516         xid = GetXid();
 517         mutex_lock(&pCifsFile->fh_mutex);
 518         if (!pCifsFile->invalidHandle) {
 519                 mutex_unlock(&pCifsFile->fh_mutex);
 520                 rc = 0;
 521                 FreeXid(xid);
 522                 return rc;
 523         }
 524
 525         inode = pCifsFile->dentry->d_inode;
 526         cifs_sb = CIFS_SB(inode->i_sb);
 527         tcon = tlink_tcon(pCifsFile->tlink);
 528
 529 /* can not grab rename sem here because various ops, including
 530    those that already have the rename sem can end up causing writepage
 531    to get called and if the server was down that means we end up here,
 532    and we can never tell if the caller already has the rename_sem */
 533         full_path = build_path_from_dentry(pCifsFile->dentry);
 534         if (full_path == NULL) {
 535                 rc = -ENOMEM;
 536                 mutex_unlock(&pCifsFile->fh_mutex);
 537                 FreeXid(xid);
 538                 return rc;
 539         }
 540
 541         cFYI(1, "inode = 0x%p file flags 0x%x for %s",
 542                  inode, pCifsFile->f_flags, full_path);
 543
 544         if (oplockEnabled)
 545                 oplock = REQ_OPLOCK;
 546         else
 547                 oplock = 0;
 548
 549         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 550             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 551                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 552
 553                 /*
 554                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 555                  * original open. Must mask them off for a reopen.
 556                  */
 557                 unsigned int oflags = pCifsFile->f_flags &
 558                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 559
 560                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 561                                 cifs_sb->mnt_file_mode /* ignored */,
 562                                 oflags, &oplock, &netfid, xid);
 563                 if (rc == 0) {
 564                         cFYI(1, "posix reopen succeeded");
 565                         goto reopen_success;
 566                 }
 567                 /* fallthrough to retry open the old way on errors, especially
 568                    in the reconnect path it is important to retry hard */
 569         }
 570
 571         desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
 572
 573         /* Can not refresh inode by passing in file_info buf to be returned
 574            by SMBOpen and then calling get_inode_info with returned buf
 575            since file might have write behind data that needs to be flushed
 576            and server version of file size can be stale. If we knew for sure
 577            that inode was not dirty locally we could do this */
 578
 579         rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
 580                          CREATE_NOT_DIR, &netfid, &oplock, NULL,
 581                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 582                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 583         if (rc) {
 584                 mutex_unlock(&pCifsFile->fh_mutex);
 585                 cFYI(1, "cifs_open returned 0x%x", rc);
 586                 cFYI(1, "oplock: %d", oplock);
 587                 goto reopen_error_exit;
 588         }
 589
 590 reopen_success:
 591         pCifsFile->netfid = netfid;
 592         pCifsFile->invalidHandle = false;
 593         mutex_unlock(&pCifsFile->fh_mutex);
 594         pCifsInode = CIFS_I(inode);
 595
 596         if (can_flush) {
 597                 rc = filemap_write_and_wait(inode->i_mapping);
 598                 mapping_set_error(inode->i_mapping, rc);
 599
 600                 if (tcon->unix_ext)
 601                         rc = cifs_get_inode_info_unix(&inode,
 602                                 full_path, inode->i_sb, xid);
 603                 else
 604                         rc = cifs_get_inode_info(&inode,
 605                                 full_path, NULL, inode->i_sb,
 606                                 xid, NULL);
 607         } /* else we are writing out data to server already
 608              and could deadlock if we tried to flush data, and
 609              since we do not know if we have data that would
 610              invalidate the current end of file on the server
 611              we can not go to the server to get the new inod
 612              info */
 613
 614         cifs_set_oplock_level(pCifsInode, oplock);
 615
 616         cifs_relock_file(pCifsFile);
 617
 618 reopen_error_exit:
 619         kfree(full_path);
 620         FreeXid(xid);
 621         return rc;
 622 }
 623
 624 int cifs_close(struct inode *inode, struct file *file)
 625 {
 626         cifsFileInfo_put(file->private_data);
 627         file->private_data = NULL;
 628
 629         /* return code from the ->release op is always ignored */
 630         return 0;
 631 }
 632
 633 int cifs_closedir(struct inode *inode, struct file *file)
 634 {
 635         int rc = 0;
 636         int xid;
 637         struct cifsFileInfo *pCFileStruct = file->private_data;
 638         char *ptmp;
 639
 640         cFYI(1, "Closedir inode = 0x%p", inode);
 641
 642         xid = GetXid();
 643
 644         if (pCFileStruct) {
 645                 struct cifsTconInfo *pTcon = tlink_tcon(pCFileStruct->tlink);
 646
 647                 cFYI(1, "Freeing private data in close dir");
 648                 spin_lock(&cifs_file_list_lock);
 649                 if (!pCFileStruct->srch_inf.endOfSearch &&
 650                     !pCFileStruct->invalidHandle) {
 651                         pCFileStruct->invalidHandle = true;
 652                         spin_unlock(&cifs_file_list_lock);
 653                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 654                         cFYI(1, "Closing uncompleted readdir with rc %d",
 655                                  rc);
 656                         /* not much we can do if it fails anyway, ignore rc */
 657                         rc = 0;
 658                 } else
 659                         spin_unlock(&cifs_file_list_lock);
 660                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 661                 if (ptmp) {
 662                         cFYI(1, "closedir free smb buf in srch struct");
 663                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 664                         if (pCFileStruct->srch_inf.smallBuf)
 665                                 cifs_small_buf_release(ptmp);
 666                         else
 667                                 cifs_buf_release(ptmp);
 668                 }
 669                 cifs_put_tlink(pCFileStruct->tlink);
 670                 kfree(file->private_data);
 671                 file->private_data = NULL;
 672         }
 673         /* BB can we lock the filestruct while this is going on? */
 674         FreeXid(xid);
 675         return rc;
 676 }
 677
 678 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
 679                                 __u64 offset, __u8 lockType)
 680 {
 681         struct cifsLockInfo *li =
 682                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 683         if (li == NULL)
 684                 return -ENOMEM;
 685         li->offset = offset;
 686         li->length = len;
 687         li->type = lockType;
 688         mutex_lock(&fid->lock_mutex);
 689         list_add(&li->llist, &fid->llist);
 690         mutex_unlock(&fid->lock_mutex);
 691         return 0;
 692 }
 693
 694 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
 695 {
 696         int rc, xid;
 697         __u32 numLock = 0;
 698         __u32 numUnlock = 0;
 699         __u64 length;
 700         bool wait_flag = false;
 701         struct cifs_sb_info *cifs_sb;
 702         struct cifsTconInfo *tcon;
 703         __u16 netfid;
 704         __u8 lockType = LOCKING_ANDX_LARGE_FILES;
 705         bool posix_locking = 0;
 706
 707         length = 1 + pfLock->fl_end - pfLock->fl_start;
 708         rc = -EACCES;
 709         xid = GetXid();
 710
 711         cFYI(1, "Lock parm: 0x%x flockflags: "
 712                  "0x%x flocktype: 0x%x start: %lld end: %lld",
 713                 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
 714                 pfLock->fl_end);
 715
 716         if (pfLock->fl_flags & FL_POSIX)
 717                 cFYI(1, "Posix");
 718         if (pfLock->fl_flags & FL_FLOCK)
 719                 cFYI(1, "Flock");
 720         if (pfLock->fl_flags & FL_SLEEP) {
 721                 cFYI(1, "Blocking lock");
 722                 wait_flag = true;
 723         }
 724         if (pfLock->fl_flags & FL_ACCESS)
 725                 cFYI(1, "Process suspended by mandatory locking - "
 726                          "not implemented yet");
 727         if (pfLock->fl_flags & FL_LEASE)
 728                 cFYI(1, "Lease on file - not implemented yet");
 729         if (pfLock->fl_flags &
 730             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
 731                 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
 732
 733         if (pfLock->fl_type == F_WRLCK) {
 734                 cFYI(1, "F_WRLCK ");
 735                 numLock = 1;
 736         } else if (pfLock->fl_type == F_UNLCK) {
 737                 cFYI(1, "F_UNLCK");
 738                 numUnlock = 1;
 739                 /* Check if unlock includes more than
 740                 one lock range */
 741         } else if (pfLock->fl_type == F_RDLCK) {
 742                 cFYI(1, "F_RDLCK");
 743                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 744                 numLock = 1;
 745         } else if (pfLock->fl_type == F_EXLCK) {
 746                 cFYI(1, "F_EXLCK");
 747                 numLock = 1;
 748         } else if (pfLock->fl_type == F_SHLCK) {
 749                 cFYI(1, "F_SHLCK");
 750                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 751                 numLock = 1;
 752         } else
 753                 cFYI(1, "Unknown type of lock");
 754
 755         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 756         tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
 757         netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
 758
 759         if ((tcon->ses->capabilities & CAP_UNIX) &&
 760             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 761             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 762                 posix_locking = 1;
 763         /* BB add code here to normalize offset and length to
 764         account for negative length which we can not accept over the
 765         wire */
 766         if (IS_GETLK(cmd)) {
 767                 if (posix_locking) {
 768                         int posix_lock_type;
 769                         if (lockType & LOCKING_ANDX_SHARED_LOCK)
 770                                 posix_lock_type = CIFS_RDLCK;
 771                         else
 772                                 posix_lock_type = CIFS_WRLCK;
 773                         rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
 774                                         length, pfLock,
 775                                         posix_lock_type, wait_flag);
 776                         FreeXid(xid);
 777                         return rc;
 778                 }
 779
 780                 /* BB we could chain these into one lock request BB */
 781                 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
 782                                  0, 1, lockType, 0 /* wait flag */ );
 783                 if (rc == 0) {
 784                         rc = CIFSSMBLock(xid, tcon, netfid, length,
 785                                          pfLock->fl_start, 1 /* numUnlock */ ,
 786                                          0 /* numLock */ , lockType,
 787                                          0 /* wait flag */ );
 788                         pfLock->fl_type = F_UNLCK;
 789                         if (rc != 0)
 790                                 cERROR(1, "Error unlocking previously locked "
 791                                            "range %d during test of lock", rc);
 792                         rc = 0;
 793
 794                 } else {
 795                         /* if rc == ERR_SHARING_VIOLATION ? */
 796                         rc = 0;
 797
 798                         if (lockType & LOCKING_ANDX_SHARED_LOCK) {
 799                                 pfLock->fl_type = F_WRLCK;
 800                         } else {
 801                                 rc = CIFSSMBLock(xid, tcon, netfid, length,
 802                                         pfLock->fl_start, 0, 1,
 803                                         lockType | LOCKING_ANDX_SHARED_LOCK,
 804                                         0 /* wait flag */);
 805                                 if (rc == 0) {
 806                                         rc = CIFSSMBLock(xid, tcon, netfid,
 807                                                 length, pfLock->fl_start, 1, 0,
 808                                                 lockType |
 809                                                 LOCKING_ANDX_SHARED_LOCK,
 810                                                 0 /* wait flag */);
 811                                         pfLock->fl_type = F_RDLCK;
 812                                         if (rc != 0)
 813                                                 cERROR(1, "Error unlocking "
 814                                                 "previously locked range %d "
 815                                                 "during test of lock", rc);
 816                                         rc = 0;
 817                                 } else {
 818                                         pfLock->fl_type = F_WRLCK;
 819                                         rc = 0;
 820                                 }
 821                         }
 822                 }
 823
 824                 FreeXid(xid);
 825                 return rc;
 826         }
 827
 828         if (!numLock && !numUnlock) {
 829                 /* if no lock or unlock then nothing
 830                 to do since we do not know what it is */
 831                 FreeXid(xid);
 832                 return -EOPNOTSUPP;
 833         }
 834
 835         if (posix_locking) {
 836                 int posix_lock_type;
 837                 if (lockType & LOCKING_ANDX_SHARED_LOCK)
 838                         posix_lock_type = CIFS_RDLCK;
 839                 else
 840                         posix_lock_type = CIFS_WRLCK;
 841
 842                 if (numUnlock == 1)
 843                         posix_lock_type = CIFS_UNLCK;
 844
 845                 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
 846                                       length, pfLock,
 847                                       posix_lock_type, wait_flag);
 848         } else {
 849                 struct cifsFileInfo *fid = file->private_data;
 850
 851                 if (numLock) {
 852                         rc = CIFSSMBLock(xid, tcon, netfid, length,
 853                                         pfLock->fl_start,
 854                                         0, numLock, lockType, wait_flag);
 855
 856                         if (rc == 0) {
 857                                 /* For Windows locks we must store them. */
 858                                 rc = store_file_lock(fid, length,
 859                                                 pfLock->fl_start, lockType);
 860                         }
 861                 } else if (numUnlock) {
 862                         /* For each stored lock that this unlock overlaps
 863                            completely, unlock it. */
 864                         int stored_rc = 0;
 865                         struct cifsLockInfo *li, *tmp;
 866
 867                         rc = 0;
 868                         mutex_lock(&fid->lock_mutex);
 869                         list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
 870                                 if (pfLock->fl_start <= li->offset &&
 871                                                 (pfLock->fl_start + length) >=
 872                                                 (li->offset + li->length)) {
 873                                         stored_rc = CIFSSMBLock(xid, tcon,
 874                                                         netfid,
 875                                                         li->length, li->offset,
 876                                                         1, 0, li->type, false);
 877                                         if (stored_rc)
 878                                                 rc = stored_rc;
 879                                         else {
 880                                                 list_del(&li->llist);
 881                                                 kfree(li);
 882                                         }
 883                                 }
 884                         }
 885                         mutex_unlock(&fid->lock_mutex);
 886                 }
 887         }
 888
 889         if (pfLock->fl_flags & FL_POSIX)
 890                 posix_lock_file_wait(file, pfLock);
 891         FreeXid(xid);
 892         return rc;
 893 }
 894
 895 /*
 896  * Set the timeout on write requests past EOF. For some servers (Windows)
 897  * these calls can be very long.
 898  *
 899  * If we're writing >10M past the EOF we give a 180s timeout. Anything less
 900  * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
 901  * The 10M cutoff is totally arbitrary. A better scheme for this would be
 902  * welcome if someone wants to suggest one.
 903  *
 904  * We may be able to do a better job with this if there were some way to
 905  * declare that a file should be sparse.
 906  */
 907 static int
 908 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
 909 {
 910         if (offset <= cifsi->server_eof)
 911                 return CIFS_STD_OP;
 912         else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
 913                 return CIFS_VLONG_OP;
 914         else
 915                 return CIFS_LONG_OP;
 916 }
 917
 918 /* update the file size (if needed) after a write */
 919 static void
 920 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
 921                       unsigned int bytes_written)
 922 {
 923         loff_t end_of_write = offset + bytes_written;
 924
 925         if (end_of_write > cifsi->server_eof)
 926                 cifsi->server_eof = end_of_write;
 927 }
 928
 929 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
 930         size_t write_size, loff_t *poffset)
 931 {
 932         struct inode *inode = file->f_path.dentry->d_inode;
 933         int rc = 0;
 934         unsigned int bytes_written = 0;
 935         unsigned int total_written;
 936         struct cifs_sb_info *cifs_sb;
 937         struct cifsTconInfo *pTcon;
 938         int xid, long_op;
 939         struct cifsFileInfo *open_file;
 940         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 941
 942         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 943
 944         /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
 945            *poffset, file->f_path.dentry->d_name.name); */
 946
 947         if (file->private_data == NULL)
 948                 return -EBADF;
 949
 950         open_file = file->private_data;
 951         pTcon = tlink_tcon(open_file->tlink);
 952
 953         rc = generic_write_checks(file, poffset, &write_size, 0);
 954         if (rc)
 955                 return rc;
 956
 957         xid = GetXid();
 958
 959         long_op = cifs_write_timeout(cifsi, *poffset);
 960         for (total_written = 0; write_size > total_written;
 961              total_written += bytes_written) {
 962                 rc = -EAGAIN;
 963                 while (rc == -EAGAIN) {
 964                         if (file->private_data == NULL) {
 965                                 /* file has been closed on us */
 966                                 FreeXid(xid);
 967                         /* if we have gotten here we have written some data
 968                            and blocked, and the file has been freed on us while
 969                            we blocked so return what we managed to write */
 970                                 return total_written;
 971                         }
 972                         if (open_file->invalidHandle) {
 973                                 /* we could deadlock if we called
 974                                    filemap_fdatawait from here so tell
 975                                    reopen_file not to flush data to server
 976                                    now */
 977                                 rc = cifs_reopen_file(open_file, false);
 978                                 if (rc != 0)
 979                                         break;
 980                         }
 981
 982                         rc = CIFSSMBWrite(xid, pTcon,
 983                                 open_file->netfid,
 984                                 min_t(const int, cifs_sb->wsize,
 985                                       write_size - total_written),
 986                                 *poffset, &bytes_written,
 987                                 NULL, write_data + total_written, long_op);
 988                 }
 989                 if (rc || (bytes_written == 0)) {
 990                         if (total_written)
 991                                 break;
 992                         else {
 993                                 FreeXid(xid);
 994                                 return rc;
 995                         }
 996                 } else {
 997                         cifs_update_eof(cifsi, *poffset, bytes_written);
 998                         *poffset += bytes_written;
 999                 }
1000                 long_op = CIFS_STD_OP; /* subsequent writes fast -
1001                                     15 seconds is plenty */
1002         }
1003
1004         cifs_stats_bytes_written(pTcon, total_written);
1005
1006 /* Do not update local mtime - server will set its actual value on write
1007  *      inode->i_ctime = inode->i_mtime =
1008  *              current_fs_time(inode->i_sb);*/
1009         if (total_written > 0) {
1010                 spin_lock(&inode->i_lock);
1011                 if (*poffset > inode->i_size)
1012                         i_size_write(inode, *poffset);
1013                 spin_unlock(&inode->i_lock);
1014         }
1015         mark_inode_dirty_sync(inode);
1016
1017         FreeXid(xid);
1018         return total_written;
1019 }
1020
1021 static ssize_t cifs_write(struct cifsFileInfo *open_file,
1022                           const char *write_data, size_t write_size,
1023                           loff_t *poffset)
1024 {
1025         int rc = 0;
1026         unsigned int bytes_written = 0;
1027         unsigned int total_written;
1028         struct cifs_sb_info *cifs_sb;
1029         struct cifsTconInfo *pTcon;
1030         int xid, long_op;
1031         struct dentry *dentry = open_file->dentry;
1032         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1033
1034         cifs_sb = CIFS_SB(dentry->d_sb);
1035
1036         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1037            *poffset, dentry->d_name.name);
1038
1039         pTcon = tlink_tcon(open_file->tlink);
1040
1041         xid = GetXid();
1042
1043         long_op = cifs_write_timeout(cifsi, *poffset);
1044         for (total_written = 0; write_size > total_written;
1045              total_written += bytes_written) {
1046                 rc = -EAGAIN;
1047                 while (rc == -EAGAIN) {
1048                         if (open_file->invalidHandle) {
1049                                 /* we could deadlock if we called
1050                                    filemap_fdatawait from here so tell
1051                                    reopen_file not to flush data to
1052                                    server now */
1053                                 rc = cifs_reopen_file(open_file, false);
1054                                 if (rc != 0)
1055                                         break;
1056                         }
1057                         if (experimEnabled || (pTcon->ses->server &&
1058                                 ((pTcon->ses->server->secMode &
1059                                 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1060                                 == 0))) {
1061                                 struct kvec iov[2];
1062                                 unsigned int len;
1063
1064                                 len = min((size_t)cifs_sb->wsize,
1065                                           write_size - total_written);
1066                                 /* iov[0] is reserved for smb header */
1067                                 iov[1].iov_base = (char *)write_data +
1068                                                   total_written;
1069                                 iov[1].iov_len = len;
1070                                 rc = CIFSSMBWrite2(xid, pTcon,
1071                                                 open_file->netfid, len,
1072                                                 *poffset, &bytes_written,
1073                                                 iov, 1, long_op);
1074                         } else
1075                                 rc = CIFSSMBWrite(xid, pTcon,
1076                                          open_file->netfid,
1077                                          min_t(const int, cifs_sb->wsize,
1078                                                write_size - total_written),
1079                                          *poffset, &bytes_written,
1080                                          write_data + total_written,
1081                                          NULL, long_op);
1082                 }
1083                 if (rc || (bytes_written == 0)) {
1084                         if (total_written)
1085                                 break;
1086                         else {
1087                                 FreeXid(xid);
1088                                 return rc;
1089                         }
1090                 } else {
1091                         cifs_update_eof(cifsi, *poffset, bytes_written);
1092                         *poffset += bytes_written;
1093                 }
1094                 long_op = CIFS_STD_OP; /* subsequent writes fast -
1095                                     15 seconds is plenty */
1096         }
1097
1098         cifs_stats_bytes_written(pTcon, total_written);
1099
1100         if (total_written > 0) {
1101                 spin_lock(&dentry->d_inode->i_lock);
1102                 if (*poffset > dentry->d_inode->i_size)
1103                         i_size_write(dentry->d_inode, *poffset);
1104                 spin_unlock(&dentry->d_inode->i_lock);
1105         }
1106         mark_inode_dirty_sync(dentry->d_inode);
1107         FreeXid(xid);
1108         return total_written;
1109 }
1110
1111 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1112                                         bool fsuid_only)
1113 {
1114         struct cifsFileInfo *open_file = NULL;
1115         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1116
1117         /* only filter by fsuid on multiuser mounts */
1118         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1119                 fsuid_only = false;
1120
1121         spin_lock(&cifs_file_list_lock);
1122         /* we could simply get the first_list_entry since write-only entries
1123            are always at the end of the list but since the first entry might
1124            have a close pending, we go through the whole list */
1125         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1126                 if (fsuid_only && open_file->uid != current_fsuid())
1127                         continue;
1128                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1129                         if (!open_file->invalidHandle) {
1130                                 /* found a good file */
1131                                 /* lock it so it will not be closed on us */
1132                                 cifsFileInfo_get(open_file);
1133                                 spin_unlock(&cifs_file_list_lock);
1134                                 return open_file;
1135                         } /* else might as well continue, and look for
1136                              another, or simply have the caller reopen it
1137                              again rather than trying to fix this handle */
1138                 } else /* write only file */
1139                         break; /* write only files are last so must be done */
1140         }
1141         spin_unlock(&cifs_file_list_lock);
1142         return NULL;
1143 }
1144
1145 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1146                                         bool fsuid_only)
1147 {
1148         struct cifsFileInfo *open_file;
1149         struct cifs_sb_info *cifs_sb;
1150         bool any_available = false;
1151         int rc;
1152
1153         /* Having a null inode here (because mapping->host was set to zero by
1154         the VFS or MM) should not happen but we had reports of on oops (due to
1155         it being zero) during stress testcases so we need to check for it */
1156
1157         if (cifs_inode == NULL) {
1158                 cERROR(1, "Null inode passed to cifs_writeable_file");
1159                 dump_stack();
1160                 return NULL;
1161         }
1162
1163         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1164
1165         /* only filter by fsuid on multiuser mounts */
1166         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1167                 fsuid_only = false;
1168
1169         spin_lock(&cifs_file_list_lock);
1170 refind_writable:
1171         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1172                 if (!any_available && open_file->pid != current->tgid)
1173                         continue;
1174                 if (fsuid_only && open_file->uid != current_fsuid())
1175                         continue;
1176                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1177                         cifsFileInfo_get(open_file);
1178
1179                         if (!open_file->invalidHandle) {
1180                                 /* found a good writable file */
1181                                 spin_unlock(&cifs_file_list_lock);
1182                                 return open_file;
1183                         }
1184
1185                         spin_unlock(&cifs_file_list_lock);
1186
1187                         /* Had to unlock since following call can block */
1188                         rc = cifs_reopen_file(open_file, false);
1189                         if (!rc)
1190                                 return open_file;
1191
1192                         /* if it fails, try another handle if possible */
1193                         cFYI(1, "wp failed on reopen file");
1194                         cifsFileInfo_put(open_file);
1195
1196                         spin_lock(&cifs_file_list_lock);
1197
1198                         /* else we simply continue to the next entry. Thus
1199                            we do not loop on reopen errors.  If we
1200                            can not reopen the file, for example if we
1201                            reconnected to a server with another client
1202                            racing to delete or lock the file we would not
1203                            make progress if we restarted before the beginning
1204                            of the loop here. */
1205                 }
1206         }
1207         /* couldn't find useable FH with same pid, try any available */
1208         if (!any_available) {
1209                 any_available = true;
1210                 goto refind_writable;
1211         }
1212         spin_unlock(&cifs_file_list_lock);
1213         return NULL;
1214 }
1215
1216 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1217 {
1218         struct address_space *mapping = page->mapping;
1219         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1220         char *write_data;
1221         int rc = -EFAULT;
1222         int bytes_written = 0;
1223         struct cifs_sb_info *cifs_sb;
1224         struct inode *inode;
1225         struct cifsFileInfo *open_file;
1226
1227         if (!mapping || !mapping->host)
1228                 return -EFAULT;
1229
1230         inode = page->mapping->host;
1231         cifs_sb = CIFS_SB(inode->i_sb);
1232
1233         offset += (loff_t)from;
1234         write_data = kmap(page);
1235         write_data += from;
1236
1237         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1238                 kunmap(page);
1239                 return -EIO;
1240         }
1241
1242         /* racing with truncate? */
1243         if (offset > mapping->host->i_size) {
1244                 kunmap(page);
1245                 return 0; /* don't care */
1246         }
1247
1248         /* check to make sure that we are not extending the file */
1249         if (mapping->host->i_size - offset < (loff_t)to)
1250                 to = (unsigned)(mapping->host->i_size - offset);
1251
1252         open_file = find_writable_file(CIFS_I(mapping->host), false);
1253         if (open_file) {
1254                 bytes_written = cifs_write(open_file, write_data,
1255                                            to - from, &offset);
1256                 cifsFileInfo_put(open_file);
1257                 /* Does mm or vfs already set times? */
1258                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1259                 if ((bytes_written > 0) && (offset))
1260                         rc = 0;
1261                 else if (bytes_written < 0)
1262                         rc = bytes_written;
1263         } else {
1264                 cFYI(1, "No writeable filehandles for inode");
1265                 rc = -EIO;
1266         }
1267
1268         kunmap(page);
1269         return rc;
1270 }
1271
1272 static int cifs_writepages(struct address_space *mapping,
1273                            struct writeback_control *wbc)
1274 {
1275         unsigned int bytes_to_write;
1276         unsigned int bytes_written;
1277         struct cifs_sb_info *cifs_sb;
1278         int done = 0;
1279         pgoff_t end;
1280         pgoff_t index;
1281         int range_whole = 0;
1282         struct kvec *iov;
1283         int len;
1284         int n_iov = 0;
1285         pgoff_t next;
1286         int nr_pages;
1287         __u64 offset = 0;
1288         struct cifsFileInfo *open_file;
1289         struct cifsTconInfo *tcon;
1290         struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1291         struct page *page;
1292         struct pagevec pvec;
1293         int rc = 0;
1294         int scanned = 0;
1295         int xid, long_op;
1296
1297         cifs_sb = CIFS_SB(mapping->host->i_sb);
1298
1299         /*
1300          * If wsize is smaller that the page cache size, default to writing
1301          * one page at a time via cifs_writepage
1302          */
1303         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1304                 return generic_writepages(mapping, wbc);
1305
1306         iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1307         if (iov == NULL)
1308                 return generic_writepages(mapping, wbc);
1309
1310         /*
1311          * if there's no open file, then this is likely to fail too,
1312          * but it'll at least handle the return. Maybe it should be
1313          * a BUG() instead?
1314          */
1315         open_file = find_writable_file(CIFS_I(mapping->host), false);
1316         if (!open_file) {
1317                 kfree(iov);
1318                 return generic_writepages(mapping, wbc);
1319         }
1320
1321         tcon = tlink_tcon(open_file->tlink);
1322         if (!experimEnabled && tcon->ses->server->secMode &
1323                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1324                 cifsFileInfo_put(open_file);
1325                 kfree(iov);
1326                 return generic_writepages(mapping, wbc);
1327         }
1328         cifsFileInfo_put(open_file);
1329
1330         xid = GetXid();
1331
1332         pagevec_init(&pvec, 0);
1333         if (wbc->range_cyclic) {
1334                 index = mapping->writeback_index; /* Start from prev offset */
1335                 end = -1;
1336         } else {
1337                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1338                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1339                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1340                         range_whole = 1;
1341                 scanned = 1;
1342         }
1343 retry:
1344         while (!done && (index <= end) &&
1345                (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1346                         PAGECACHE_TAG_DIRTY,
1347                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1348                 int first;
1349                 unsigned int i;
1350
1351                 first = -1;
1352                 next = 0;
1353                 n_iov = 0;
1354                 bytes_to_write = 0;
1355
1356                 for (i = 0; i < nr_pages; i++) {
1357                         page = pvec.pages[i];
1358                         /*
1359                          * At this point we hold neither mapping->tree_lock nor
1360                          * lock on the page itself: the page may be truncated or
1361                          * invalidated (changing page->mapping to NULL), or even
1362                          * swizzled back from swapper_space to tmpfs file
1363                          * mapping
1364                          */
1365
1366                         if (first < 0)
1367                                 lock_page(page);
1368                         else if (!trylock_page(page))
1369                                 break;
1370
1371                         if (unlikely(page->mapping != mapping)) {
1372                                 unlock_page(page);
1373                                 break;
1374                         }
1375
1376                         if (!wbc->range_cyclic && page->index > end) {
1377                                 done = 1;
1378                                 unlock_page(page);
1379                                 break;
1380                         }
1381
1382                         if (next && (page->index != next)) {
1383                                 /* Not next consecutive page */
1384                                 unlock_page(page);
1385                                 break;
1386                         }
1387
1388                         if (wbc->sync_mode != WB_SYNC_NONE)
1389                                 wait_on_page_writeback(page);
1390
1391                         if (PageWriteback(page) ||
1392                                         !clear_page_dirty_for_io(page)) {
1393                                 unlock_page(page);
1394                                 break;
1395                         }
1396
1397                         /*
1398                          * This actually clears the dirty bit in the radix tree.
1399                          * See cifs_writepage() for more commentary.
1400                          */
1401                         set_page_writeback(page);
1402
1403                         if (page_offset(page) >= mapping->host->i_size) {
1404                                 done = 1;
1405                                 unlock_page(page);
1406                                 end_page_writeback(page);
1407                                 break;
1408                         }
1409
1410                         /*
1411                          * BB can we get rid of this?  pages are held by pvec
1412                          */
1413                         page_cache_get(page);
1414
1415                         len = min(mapping->host->i_size - page_offset(page),
1416                                   (loff_t)PAGE_CACHE_SIZE);
1417
1418                         /* reserve iov[0] for the smb header */
1419                         n_iov++;
1420                         iov[n_iov].iov_base = kmap(page);
1421                         iov[n_iov].iov_len = len;
1422                         bytes_to_write += len;
1423
1424                         if (first < 0) {
1425                                 first = i;
1426                                 offset = page_offset(page);
1427                         }
1428                         next = page->index + 1;
1429                         if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1430                                 break;
1431                 }
1432                 if (n_iov) {
1433                         open_file = find_writable_file(CIFS_I(mapping->host),
1434                                                         false);
1435                         if (!open_file) {
1436                                 cERROR(1, "No writable handles for inode");
1437                                 rc = -EBADF;
1438                         } else {
1439                                 long_op = cifs_write_timeout(cifsi, offset);
1440                                 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
1441                                                    bytes_to_write, offset,
1442                                                    &bytes_written, iov, n_iov,
1443                                                    long_op);
1444                                 cifsFileInfo_put(open_file);
1445                                 cifs_update_eof(cifsi, offset, bytes_written);
1446                         }
1447
1448                         if (rc || bytes_written < bytes_to_write) {
1449                                 cERROR(1, "Write2 ret %d, wrote %d",
1450                                           rc, bytes_written);
1451                                 mapping_set_error(mapping, rc);
1452                         } else {
1453                                 cifs_stats_bytes_written(tcon, bytes_written);
1454                         }
1455
1456                         for (i = 0; i < n_iov; i++) {
1457                                 page = pvec.pages[first + i];
1458                                 /* Should we also set page error on
1459                                 success rc but too little data written? */
1460                                 /* BB investigate retry logic on temporary
1461                                 server crash cases and how recovery works
1462                                 when page marked as error */
1463                                 if (rc)
1464                                         SetPageError(page);
1465                                 kunmap(page);
1466                                 unlock_page(page);
1467                                 end_page_writeback(page);
1468                                 page_cache_release(page);
1469                         }
1470                         if ((wbc->nr_to_write -= n_iov) <= 0)
1471                                 done = 1;
1472                         index = next;
1473                 } else
1474                         /* Need to re-find the pages we skipped */
1475                         index = pvec.pages[0]->index + 1;
1476
1477                 pagevec_release(&pvec);
1478         }
1479         if (!scanned && !done) {
1480                 /*
1481                  * We hit the last page and there is more work to be done: wrap
1482                  * back to the start of the file
1483                  */
1484                 scanned = 1;
1485                 index = 0;
1486                 goto retry;
1487         }
1488         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1489                 mapping->writeback_index = index;
1490
1491         FreeXid(xid);
1492         kfree(iov);
1493         return rc;
1494 }
1495
1496 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1497 {
1498         int rc = -EFAULT;
1499         int xid;
1500
1501         xid = GetXid();
1502 /* BB add check for wbc flags */
1503         page_cache_get(page);
1504         if (!PageUptodate(page))
1505                 cFYI(1, "ppw - page not up to date");
1506
1507         /*
1508          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1509          *
1510          * A writepage() implementation always needs to do either this,
1511          * or re-dirty the page with "redirty_page_for_writepage()" in
1512          * the case of a failure.
1513          *
1514          * Just unlocking the page will cause the radix tree tag-bits
1515          * to fail to update with the state of the page correctly.
1516          */
1517         set_page_writeback(page);
1518         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1519         SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1520         unlock_page(page);
1521         end_page_writeback(page);
1522         page_cache_release(page);
1523         FreeXid(xid);
1524         return rc;
1525 }
1526
1527 static int cifs_write_end(struct file *file, struct address_space *mapping,
1528                         loff_t pos, unsigned len, unsigned copied,
1529                         struct page *page, void *fsdata)
1530 {
1531         int rc;
1532         struct inode *inode = mapping->host;
1533
1534         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1535                  page, pos, copied);
1536
1537         if (PageChecked(page)) {
1538                 if (copied == len)
1539                         SetPageUptodate(page);
1540                 ClearPageChecked(page);
1541         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1542                 SetPageUptodate(page);
1543
1544         if (!PageUptodate(page)) {
1545                 char *page_data;
1546                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1547                 int xid;
1548
1549                 xid = GetXid();
1550                 /* this is probably better than directly calling
1551                    partialpage_write since in this function the file handle is
1552                    known which we might as well leverage */
1553                 /* BB check if anything else missing out of ppw
1554                    such as updating last write time */
1555                 page_data = kmap(page);
1556                 rc = cifs_write(file->private_data, page_data + offset,
1557                                 copied, &pos);
1558                 /* if (rc < 0) should we set writebehind rc? */
1559                 kunmap(page);
1560
1561                 FreeXid(xid);
1562         } else {
1563                 rc = copied;
1564                 pos += copied;
1565                 set_page_dirty(page);
1566         }
1567
1568         if (rc > 0) {
1569                 spin_lock(&inode->i_lock);
1570                 if (pos > inode->i_size)
1571                         i_size_write(inode, pos);
1572                 spin_unlock(&inode->i_lock);
1573         }
1574
1575         unlock_page(page);
1576         page_cache_release(page);
1577
1578         return rc;
1579 }
1580
1581 int cifs_fsync(struct file *file, int datasync)
1582 {
1583         int xid;
1584         int rc = 0;
1585         struct cifsTconInfo *tcon;
1586         struct cifsFileInfo *smbfile = file->private_data;
1587         struct inode *inode = file->f_path.dentry->d_inode;
1588
1589         xid = GetXid();
1590
1591         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1592                 file->f_path.dentry->d_name.name, datasync);
1593
1594         rc = filemap_write_and_wait(inode->i_mapping);
1595         if (rc == 0) {
1596                 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1597
1598                 tcon = tlink_tcon(smbfile->tlink);
1599                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1600                         rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1601         }
1602
1603         FreeXid(xid);
1604         return rc;
1605 }
1606
1607 /* static void cifs_sync_page(struct page *page)
1608 {
1609         struct address_space *mapping;
1610         struct inode *inode;
1611         unsigned long index = page->index;
1612         unsigned int rpages = 0;
1613         int rc = 0;
1614
1615         cFYI(1, "sync page %p", page);
1616         mapping = page->mapping;
1617         if (!mapping)
1618                 return 0;
1619         inode = mapping->host;
1620         if (!inode)
1621                 return; */
1622
1623 /*      fill in rpages then
1624         result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1625
1626 /*      cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1627
1628 #if 0
1629         if (rc < 0)
1630                 return rc;
1631         return 0;
1632 #endif
1633 } */
1634
1635 /*
1636  * As file closes, flush all cached write data for this inode checking
1637  * for write behind errors.
1638  */
1639 int cifs_flush(struct file *file, fl_owner_t id)
1640 {
1641         struct inode *inode = file->f_path.dentry->d_inode;
1642         int rc = 0;
1643
1644         if (file->f_mode & FMODE_WRITE)
1645                 rc = filemap_write_and_wait(inode->i_mapping);
1646
1647         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1648
1649         return rc;
1650 }
1651
1652 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1653         size_t read_size, loff_t *poffset)
1654 {
1655         int rc = -EACCES;
1656         unsigned int bytes_read = 0;
1657         unsigned int total_read = 0;
1658         unsigned int current_read_size;
1659         struct cifs_sb_info *cifs_sb;
1660         struct cifsTconInfo *pTcon;
1661         int xid;
1662         struct cifsFileInfo *open_file;
1663         char *smb_read_data;
1664         char __user *current_offset;
1665         struct smb_com_read_rsp *pSMBr;
1666
1667         xid = GetXid();
1668         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1669
1670         if (file->private_data == NULL) {
1671                 rc = -EBADF;
1672                 FreeXid(xid);
1673                 return rc;
1674         }
1675         open_file = file->private_data;
1676         pTcon = tlink_tcon(open_file->tlink);
1677
1678         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1679                 cFYI(1, "attempting read on write only file instance");
1680
1681         for (total_read = 0, current_offset = read_data;
1682              read_size > total_read;
1683              total_read += bytes_read, current_offset += bytes_read) {
1684                 current_read_size = min_t(const int, read_size - total_read,
1685                                           cifs_sb->rsize);
1686                 rc = -EAGAIN;
1687                 smb_read_data = NULL;
1688                 while (rc == -EAGAIN) {
1689                         int buf_type = CIFS_NO_BUFFER;
1690                         if (open_file->invalidHandle) {
1691                                 rc = cifs_reopen_file(open_file, true);
1692                                 if (rc != 0)
1693                                         break;
1694                         }
1695                         rc = CIFSSMBRead(xid, pTcon,
1696                                          open_file->netfid,
1697                                          current_read_size, *poffset,
1698                                          &bytes_read, &smb_read_data,
1699                                          &buf_type);
1700                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1701                         if (smb_read_data) {
1702                                 if (copy_to_user(current_offset,
1703                                                 smb_read_data +
1704                                                 4 /* RFC1001 length field */ +
1705                                                 le16_to_cpu(pSMBr->DataOffset),
1706                                                 bytes_read))
1707                                         rc = -EFAULT;
1708
1709                                 if (buf_type == CIFS_SMALL_BUFFER)
1710                                         cifs_small_buf_release(smb_read_data);
1711                                 else if (buf_type == CIFS_LARGE_BUFFER)
1712                                         cifs_buf_release(smb_read_data);
1713                                 smb_read_data = NULL;
1714                         }
1715                 }
1716                 if (rc || (bytes_read == 0)) {
1717                         if (total_read) {
1718                                 break;
1719                         } else {
1720                                 FreeXid(xid);
1721                                 return rc;
1722                         }
1723                 } else {
1724                         cifs_stats_bytes_read(pTcon, bytes_read);
1725                         *poffset += bytes_read;
1726                 }
1727         }
1728         FreeXid(xid);
1729         return total_read;
1730 }
1731
1732
1733 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1734         loff_t *poffset)
1735 {
1736         int rc = -EACCES;
1737         unsigned int bytes_read = 0;
1738         unsigned int total_read;
1739         unsigned int current_read_size;
1740         struct cifs_sb_info *cifs_sb;
1741         struct cifsTconInfo *pTcon;
1742         int xid;
1743         char *current_offset;
1744         struct cifsFileInfo *open_file;
1745         int buf_type = CIFS_NO_BUFFER;
1746
1747         xid = GetXid();
1748         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1749
1750         if (file->private_data == NULL) {
1751                 rc = -EBADF;
1752                 FreeXid(xid);
1753                 return rc;
1754         }
1755         open_file = file->private_data;
1756         pTcon = tlink_tcon(open_file->tlink);
1757
1758         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1759                 cFYI(1, "attempting read on write only file instance");
1760
1761         for (total_read = 0, current_offset = read_data;
1762              read_size > total_read;
1763              total_read += bytes_read, current_offset += bytes_read) {
1764                 current_read_size = min_t(const int, read_size - total_read,
1765                                           cifs_sb->rsize);
1766                 /* For windows me and 9x we do not want to request more
1767                 than it negotiated since it will refuse the read then */
1768                 if ((pTcon->ses) &&
1769                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1770                         current_read_size = min_t(const int, current_read_size,
1771                                         pTcon->ses->server->maxBuf - 128);
1772                 }
1773                 rc = -EAGAIN;
1774                 while (rc == -EAGAIN) {
1775                         if (open_file->invalidHandle) {
1776                                 rc = cifs_reopen_file(open_file, true);
1777                                 if (rc != 0)
1778                                         break;
1779                         }
1780                         rc = CIFSSMBRead(xid, pTcon,
1781                                          open_file->netfid,
1782                                          current_read_size, *poffset,
1783                                          &bytes_read, &current_offset,
1784                                          &buf_type);
1785                 }
1786                 if (rc || (bytes_read == 0)) {
1787                         if (total_read) {
1788                                 break;
1789                         } else {
1790                                 FreeXid(xid);
1791                                 return rc;
1792                         }
1793                 } else {
1794                         cifs_stats_bytes_read(pTcon, total_read);
1795                         *poffset += bytes_read;
1796                 }
1797         }
1798         FreeXid(xid);
1799         return total_read;
1800 }
1801
1802 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1803 {
1804         int rc, xid;
1805
1806         xid = GetXid();
1807         rc = cifs_revalidate_file(file);
1808         if (rc) {
1809                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1810                 FreeXid(xid);
1811                 return rc;
1812         }
1813         rc = generic_file_mmap(file, vma);
1814         FreeXid(xid);
1815         return rc;
1816 }
1817
1818
1819 static void cifs_copy_cache_pages(struct address_space *mapping,
1820         struct list_head *pages, int bytes_read, char *data)
1821 {
1822         struct page *page;
1823         char *target;
1824
1825         while (bytes_read > 0) {
1826                 if (list_empty(pages))
1827                         break;
1828
1829                 page = list_entry(pages->prev, struct page, lru);
1830                 list_del(&page->lru);
1831
1832                 if (add_to_page_cache_lru(page, mapping, page->index,
1833                                       GFP_KERNEL)) {
1834                         page_cache_release(page);
1835                         cFYI(1, "Add page cache failed");
1836                         data += PAGE_CACHE_SIZE;
1837                         bytes_read -= PAGE_CACHE_SIZE;
1838                         continue;
1839                 }
1840                 page_cache_release(page);
1841
1842                 target = kmap_atomic(page, KM_USER0);
1843
1844                 if (PAGE_CACHE_SIZE > bytes_read) {
1845                         memcpy(target, data, bytes_read);
1846                         /* zero the tail end of this partial page */
1847                         memset(target + bytes_read, 0,
1848                                PAGE_CACHE_SIZE - bytes_read);
1849                         bytes_read = 0;
1850                 } else {
1851                         memcpy(target, data, PAGE_CACHE_SIZE);
1852                         bytes_read -= PAGE_CACHE_SIZE;
1853                 }
1854                 kunmap_atomic(target, KM_USER0);
1855
1856                 flush_dcache_page(page);
1857                 SetPageUptodate(page);
1858                 unlock_page(page);
1859                 data += PAGE_CACHE_SIZE;
1860
1861                 /* add page to FS-Cache */
1862                 cifs_readpage_to_fscache(mapping->host, page);
1863         }
1864         return;
1865 }
1866
1867 static int cifs_readpages(struct file *file, struct address_space *mapping,
1868         struct list_head *page_list, unsigned num_pages)
1869 {
1870         int rc = -EACCES;
1871         int xid;
1872         loff_t offset;
1873         struct page *page;
1874         struct cifs_sb_info *cifs_sb;
1875         struct cifsTconInfo *pTcon;
1876         unsigned int bytes_read = 0;
1877         unsigned int read_size, i;
1878         char *smb_read_data = NULL;
1879         struct smb_com_read_rsp *pSMBr;
1880         struct cifsFileInfo *open_file;
1881         int buf_type = CIFS_NO_BUFFER;
1882
1883         xid = GetXid();
1884         if (file->private_data == NULL) {
1885                 rc = -EBADF;
1886                 FreeXid(xid);
1887                 return rc;
1888         }
1889         open_file = file->private_data;
1890         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1891         pTcon = tlink_tcon(open_file->tlink);
1892
1893         /*
1894          * Reads as many pages as possible from fscache. Returns -ENOBUFS
1895          * immediately if the cookie is negative
1896          */
1897         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1898                                          &num_pages);
1899         if (rc == 0)
1900                 goto read_complete;
1901
1902         cFYI(DBG2, "rpages: num pages %d", num_pages);
1903         for (i = 0; i < num_pages; ) {
1904                 unsigned contig_pages;
1905                 struct page *tmp_page;
1906                 unsigned long expected_index;
1907
1908                 if (list_empty(page_list))
1909                         break;
1910
1911                 page = list_entry(page_list->prev, struct page, lru);
1912                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1913
1914                 /* count adjacent pages that we will read into */
1915                 contig_pages = 0;
1916                 expected_index =
1917                         list_entry(page_list->prev, struct page, lru)->index;
1918                 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1919                         if (tmp_page->index == expected_index) {
1920                                 contig_pages++;
1921                                 expected_index++;
1922                         } else
1923                                 break;
1924                 }
1925                 if (contig_pages + i >  num_pages)
1926                         contig_pages = num_pages - i;
1927
1928                 /* for reads over a certain size could initiate async
1929                    read ahead */
1930
1931                 read_size = contig_pages * PAGE_CACHE_SIZE;
1932                 /* Read size needs to be in multiples of one page */
1933                 read_size = min_t(const unsigned int, read_size,
1934                                   cifs_sb->rsize & PAGE_CACHE_MASK);
1935                 cFYI(DBG2, "rpages: read size 0x%x  contiguous pages %d",
1936                                 read_size, contig_pages);
1937                 rc = -EAGAIN;
1938                 while (rc == -EAGAIN) {
1939                         if (open_file->invalidHandle) {
1940                                 rc = cifs_reopen_file(open_file, true);
1941                                 if (rc != 0)
1942                                         break;
1943                         }
1944
1945                         rc = CIFSSMBRead(xid, pTcon,
1946                                          open_file->netfid,
1947                                          read_size, offset,
1948                                          &bytes_read, &smb_read_data,
1949                                          &buf_type);
1950                         /* BB more RC checks ? */
1951                         if (rc == -EAGAIN) {
1952                                 if (smb_read_data) {
1953                                         if (buf_type == CIFS_SMALL_BUFFER)
1954                                                 cifs_small_buf_release(smb_read_data);
1955                                         else if (buf_type == CIFS_LARGE_BUFFER)
1956                                                 cifs_buf_release(smb_read_data);
1957                                         smb_read_data = NULL;
1958                                 }
1959                         }
1960                 }
1961                 if ((rc < 0) || (smb_read_data == NULL)) {
1962                         cFYI(1, "Read error in readpages: %d", rc);
1963                         break;
1964                 } else if (bytes_read > 0) {
1965                         task_io_account_read(bytes_read);
1966                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1967                         cifs_copy_cache_pages(mapping, page_list, bytes_read,
1968                                 smb_read_data + 4 /* RFC1001 hdr */ +
1969                                 le16_to_cpu(pSMBr->DataOffset));
1970
1971                         i +=  bytes_read >> PAGE_CACHE_SHIFT;
1972                         cifs_stats_bytes_read(pTcon, bytes_read);
1973                         if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1974                                 i++; /* account for partial page */
1975
1976                                 /* server copy of file can have smaller size
1977                                    than client */
1978                                 /* BB do we need to verify this common case ?
1979                                    this case is ok - if we are at server EOF
1980                                    we will hit it on next read */
1981
1982                                 /* break; */
1983                         }
1984                 } else {
1985                         cFYI(1, "No bytes read (%d) at offset %lld . "
1986                                 "Cleaning remaining pages from readahead list",
1987                                 bytes_read, offset);
1988                         /* BB turn off caching and do new lookup on
1989                            file size at server? */
1990                         break;
1991                 }
1992                 if (smb_read_data) {
1993                         if (buf_type == CIFS_SMALL_BUFFER)
1994                                 cifs_small_buf_release(smb_read_data);
1995                         else if (buf_type == CIFS_LARGE_BUFFER)
1996                                 cifs_buf_release(smb_read_data);
1997                         smb_read_data = NULL;
1998                 }
1999                 bytes_read = 0;
2000         }
2001
2002 /* need to free smb_read_data buf before exit */
2003         if (smb_read_data) {
2004                 if (buf_type == CIFS_SMALL_BUFFER)
2005                         cifs_small_buf_release(smb_read_data);
2006                 else if (buf_type == CIFS_LARGE_BUFFER)
2007                         cifs_buf_release(smb_read_data);
2008                 smb_read_data = NULL;
2009         }
2010
2011 read_complete:
2012         FreeXid(xid);
2013         return rc;
2014 }
2015
2016 static int cifs_readpage_worker(struct file *file, struct page *page,
2017         loff_t *poffset)
2018 {
2019         char *read_data;
2020         int rc;
2021
2022         /* Is the page cached? */
2023         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2024         if (rc == 0)
2025                 goto read_complete;
2026
2027         page_cache_get(page);
2028         read_data = kmap(page);
2029         /* for reads over a certain size could initiate async read ahead */
2030
2031         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2032
2033         if (rc < 0)
2034                 goto io_error;
2035         else
2036                 cFYI(1, "Bytes read %d", rc);
2037
2038         file->f_path.dentry->d_inode->i_atime =
2039                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2040
2041         if (PAGE_CACHE_SIZE > rc)
2042                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2043
2044         flush_dcache_page(page);
2045         SetPageUptodate(page);
2046
2047         /* send this page to the cache */
2048         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2049
2050         rc = 0;
2051
2052 io_error:
2053         kunmap(page);
2054         page_cache_release(page);
2055
2056 read_complete:
2057         return rc;
2058 }
2059
2060 static int cifs_readpage(struct file *file, struct page *page)
2061 {
2062         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2063         int rc = -EACCES;
2064         int xid;
2065
2066         xid = GetXid();
2067
2068         if (file->private_data == NULL) {
2069                 rc = -EBADF;
2070                 FreeXid(xid);
2071                 return rc;
2072         }
2073
2074         cFYI(1, "readpage %p at offset %d 0x%x\n",
2075                  page, (int)offset, (int)offset);
2076
2077         rc = cifs_readpage_worker(file, page, &offset);
2078
2079         unlock_page(page);
2080
2081         FreeXid(xid);
2082         return rc;
2083 }
2084
2085 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2086 {
2087         struct cifsFileInfo *open_file;
2088
2089         spin_lock(&cifs_file_list_lock);
2090         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2091                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2092                         spin_unlock(&cifs_file_list_lock);
2093                         return 1;
2094                 }
2095         }
2096         spin_unlock(&cifs_file_list_lock);
2097         return 0;
2098 }
2099
2100 /* We do not want to update the file size from server for inodes
2101    open for write - to avoid races with writepage extending
2102    the file - in the future we could consider allowing
2103    refreshing the inode only on increases in the file size
2104    but this is tricky to do without racing with writebehind
2105    page caching in the current Linux kernel design */
2106 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2107 {
2108         if (!cifsInode)
2109                 return true;
2110
2111         if (is_inode_writable(cifsInode)) {
2112                 /* This inode is open for write at least once */
2113                 struct cifs_sb_info *cifs_sb;
2114
2115                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2116                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2117                         /* since no page cache to corrupt on directio
2118                         we can change size safely */
2119                         return true;
2120                 }
2121
2122                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2123                         return true;
2124
2125                 return false;
2126         } else
2127                 return true;
2128 }
2129
2130 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2131                         loff_t pos, unsigned len, unsigned flags,
2132                         struct page **pagep, void **fsdata)
2133 {
2134         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2135         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2136         loff_t page_start = pos & PAGE_MASK;
2137         loff_t i_size;
2138         struct page *page;
2139         int rc = 0;
2140
2141         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2142
2143         page = grab_cache_page_write_begin(mapping, index, flags);
2144         if (!page) {
2145                 rc = -ENOMEM;
2146                 goto out;
2147         }
2148
2149         if (PageUptodate(page))
2150                 goto out;
2151
2152         /*
2153          * If we write a full page it will be up to date, no need to read from
2154          * the server. If the write is short, we'll end up doing a sync write
2155          * instead.
2156          */
2157         if (len == PAGE_CACHE_SIZE)
2158                 goto out;
2159
2160         /*
2161          * optimize away the read when we have an oplock, and we're not
2162          * expecting to use any of the data we'd be reading in. That
2163          * is, when the page lies beyond the EOF, or straddles the EOF
2164          * and the write will cover all of the existing data.
2165          */
2166         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2167                 i_size = i_size_read(mapping->host);
2168                 if (page_start >= i_size ||
2169                     (offset == 0 && (pos + len) >= i_size)) {
2170                         zero_user_segments(page, 0, offset,
2171                                            offset + len,
2172                                            PAGE_CACHE_SIZE);
2173                         /*
2174                          * PageChecked means that the parts of the page
2175                          * to which we're not writing are considered up
2176                          * to date. Once the data is copied to the
2177                          * page, it can be set uptodate.
2178                          */
2179                         SetPageChecked(page);
2180                         goto out;
2181                 }
2182         }
2183
2184         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2185                 /*
2186                  * might as well read a page, it is fast enough. If we get
2187                  * an error, we don't need to return it. cifs_write_end will
2188                  * do a sync write instead since PG_uptodate isn't set.
2189                  */
2190                 cifs_readpage_worker(file, page, &page_start);
2191         } else {
2192                 /* we could try using another file handle if there is one -
2193                    but how would we lock it to prevent close of that handle
2194                    racing with this read? In any case
2195                    this will be written out by write_end so is fine */
2196         }
2197 out:
2198         *pagep = page;
2199         return rc;
2200 }
2201
2202 static int cifs_release_page(struct page *page, gfp_t gfp)
2203 {
2204         if (PagePrivate(page))
2205                 return 0;
2206
2207         return cifs_fscache_release_page(page, gfp);
2208 }
2209
2210 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2211 {
2212         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2213
2214         if (offset == 0)
2215                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2216 }
2217
2218 void cifs_oplock_break(struct work_struct *work)
2219 {
2220         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2221                                                   oplock_break);
2222         struct inode *inode = cfile->dentry->d_inode;
2223         struct cifsInodeInfo *cinode = CIFS_I(inode);
2224         int rc = 0;
2225
2226         if (inode && S_ISREG(inode->i_mode)) {
2227                 if (cinode->clientCanCacheRead)
2228                         break_lease(inode, O_RDONLY);
2229                 else
2230                         break_lease(inode, O_WRONLY);
2231                 rc = filemap_fdatawrite(inode->i_mapping);
2232                 if (cinode->clientCanCacheRead == 0) {
2233                         rc = filemap_fdatawait(inode->i_mapping);
2234                         mapping_set_error(inode->i_mapping, rc);
2235                         invalidate_remote_inode(inode);
2236                 }
2237                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2238         }
2239
2240         /*
2241          * releasing stale oplock after recent reconnect of smb session using
2242          * a now incorrect file handle is not a data integrity issue but do
2243          * not bother sending an oplock release if session to server still is
2244          * disconnected since oplock already released by the server
2245          */
2246         if (!cfile->oplock_break_cancelled) {
2247                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2248                                  0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
2249                 cFYI(1, "Oplock release rc = %d", rc);
2250         }
2251
2252         /*
2253          * We might have kicked in before is_valid_oplock_break()
2254          * finished grabbing reference for us.  Make sure it's done by
2255          * waiting for cifs_file_list_lock.
2256          */
2257         spin_lock(&cifs_file_list_lock);
2258         spin_unlock(&cifs_file_list_lock);
2259
2260         cifs_oplock_break_put(cfile);
2261 }
2262
2263 /* must be called while holding cifs_file_list_lock */
2264 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2265 {
2266         cifs_sb_active(cfile->dentry->d_sb);
2267         cifsFileInfo_get(cfile);
2268 }
2269
2270 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2271 {
2272         struct super_block *sb = cfile->dentry->d_sb;
2273
2274         cifsFileInfo_put(cfile);
2275         cifs_sb_deactive(sb);
2276 }
2277
2278 const struct address_space_operations cifs_addr_ops = {
2279         .readpage = cifs_readpage,
2280         .readpages = cifs_readpages,
2281         .writepage = cifs_writepage,
2282         .writepages = cifs_writepages,
2283         .write_begin = cifs_write_begin,
2284         .write_end = cifs_write_end,
2285         .set_page_dirty = __set_page_dirty_nobuffers,
2286         .releasepage = cifs_release_page,
2287         .invalidatepage = cifs_invalidate_page,
2288         /* .sync_page = cifs_sync_page, */
2289         /* .direct_IO = */
2290 };
2291
2292 /*
2293  * cifs_readpages requires the server to support a buffer large enough to
2294  * contain the header plus one complete page of data.  Otherwise, we need
2295  * to leave cifs_readpages out of the address space operations.
2296  */
2297 const struct address_space_operations cifs_addr_ops_smallbuf = {
2298         .readpage = cifs_readpage,
2299         .writepage = cifs_writepage,
2300         .writepages = cifs_writepages,
2301         .write_begin = cifs_write_begin,
2302         .write_end = cifs_write_end,
2303         .set_page_dirty = __set_page_dirty_nobuffers,
2304         .releasepage = cifs_release_page,
2305         .invalidatepage = cifs_invalidate_page,
2306         /* .sync_page = cifs_sync_page, */
2307         /* .direct_IO = */
2308 };