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