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