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