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