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