fs/cifs/file.c

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