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