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_FMODE(open_file->f_flags) & FMODE_READ) {
1148                         if (!open_file->invalidHandle) {
1149                                 /* found a good file */
1150                                 /* lock it so it will not be closed on us */
1151                                 cifsFileInfo_get(open_file);
1152                                 read_unlock(&GlobalSMBSeslock);
1153                                 return open_file;
1154                         } /* else might as well continue, and look for
1155                              another, or simply have the caller reopen it
1156                              again rather than trying to fix this handle */
1157                 } else /* write only file */
1158                         break; /* write only files are last so must be done */
1159         }
1160         read_unlock(&GlobalSMBSeslock);
1161         return NULL;
1162 }
1163 #endif
1164
1165 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1166                                         bool fsuid_only)
1167 {
1168         struct cifsFileInfo *open_file;
1169         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1170         bool any_available = false;
1171         int rc;
1172
1173         /* Having a null inode here (because mapping->host was set to zero by
1174         the VFS or MM) should not happen but we had reports of on oops (due to
1175         it being zero) during stress testcases so we need to check for it */
1176
1177         if (cifs_inode == NULL) {
1178                 cERROR(1, "Null inode passed to cifs_writeable_file");
1179                 dump_stack();
1180                 return NULL;
1181         }
1182
1183         /* only filter by fsuid on multiuser mounts */
1184         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1185                 fsuid_only = false;
1186
1187         read_lock(&GlobalSMBSeslock);
1188 refind_writable:
1189         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1190                 if (open_file->closePend)
1191                         continue;
1192                 if (!any_available && open_file->pid != current->tgid)
1193                         continue;
1194                 if (fsuid_only && open_file->uid != current_fsuid())
1195                         continue;
1196                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1197                         cifsFileInfo_get(open_file);
1198
1199                         if (!open_file->invalidHandle) {
1200                                 /* found a good writable file */
1201                                 read_unlock(&GlobalSMBSeslock);
1202                                 return open_file;
1203                         }
1204
1205                         read_unlock(&GlobalSMBSeslock);
1206                         /* Had to unlock since following call can block */
1207                         rc = cifs_reopen_file(open_file, false);
1208                         if (!rc) {
1209                                 if (!open_file->closePend)
1210                                         return open_file;
1211                                 else { /* start over in case this was deleted */
1212                                        /* since the list could be modified */
1213                                         read_lock(&GlobalSMBSeslock);
1214                                         cifsFileInfo_put(open_file);
1215                                         goto refind_writable;
1216                                 }
1217                         }
1218
1219                         /* if it fails, try another handle if possible -
1220                         (we can not do this if closePending since
1221                         loop could be modified - in which case we
1222                         have to start at the beginning of the list
1223                         again. Note that it would be bad
1224                         to hold up writepages here (rather than
1225                         in caller) with continuous retries */
1226                         cFYI(1, "wp failed on reopen file");
1227                         read_lock(&GlobalSMBSeslock);
1228                         /* can not use this handle, no write
1229                            pending on this one after all */
1230                         cifsFileInfo_put(open_file);
1231
1232                         if (open_file->closePend) /* list could have changed */
1233                                 goto refind_writable;
1234                         /* else we simply continue to the next entry. Thus
1235                            we do not loop on reopen errors.  If we
1236                            can not reopen the file, for example if we
1237                            reconnected to a server with another client
1238                            racing to delete or lock the file we would not
1239                            make progress if we restarted before the beginning
1240                            of the loop here. */
1241                 }
1242         }
1243         /* couldn't find useable FH with same pid, try any available */
1244         if (!any_available) {
1245                 any_available = true;
1246                 goto refind_writable;
1247         }
1248         read_unlock(&GlobalSMBSeslock);
1249         return NULL;
1250 }
1251
1252 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1253 {
1254         struct address_space *mapping = page->mapping;
1255         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1256         char *write_data;
1257         int rc = -EFAULT;
1258         int bytes_written = 0;
1259         struct cifs_sb_info *cifs_sb;
1260         struct inode *inode;
1261         struct cifsFileInfo *open_file;
1262
1263         if (!mapping || !mapping->host)
1264                 return -EFAULT;
1265
1266         inode = page->mapping->host;
1267         cifs_sb = CIFS_SB(inode->i_sb);
1268
1269         offset += (loff_t)from;
1270         write_data = kmap(page);
1271         write_data += from;
1272
1273         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1274                 kunmap(page);
1275                 return -EIO;
1276         }
1277
1278         /* racing with truncate? */
1279         if (offset > mapping->host->i_size) {
1280                 kunmap(page);
1281                 return 0; /* don't care */
1282         }
1283
1284         /* check to make sure that we are not extending the file */
1285         if (mapping->host->i_size - offset < (loff_t)to)
1286                 to = (unsigned)(mapping->host->i_size - offset);
1287
1288         open_file = find_writable_file(CIFS_I(mapping->host), false);
1289         if (open_file) {
1290                 bytes_written = cifs_write(open_file, write_data,
1291                                            to - from, &offset);
1292                 cifsFileInfo_put(open_file);
1293                 /* Does mm or vfs already set times? */
1294                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1295                 if ((bytes_written > 0) && (offset))
1296                         rc = 0;
1297                 else if (bytes_written < 0)
1298                         rc = bytes_written;
1299         } else {
1300                 cFYI(1, "No writeable filehandles for inode");
1301                 rc = -EIO;
1302         }
1303
1304         kunmap(page);
1305         return rc;
1306 }
1307
1308 static int cifs_writepages(struct address_space *mapping,
1309                            struct writeback_control *wbc)
1310 {
1311         struct backing_dev_info *bdi = mapping->backing_dev_info;
1312         unsigned int bytes_to_write;
1313         unsigned int bytes_written;
1314         struct cifs_sb_info *cifs_sb;
1315         int done = 0;
1316         pgoff_t end;
1317         pgoff_t index;
1318         int range_whole = 0;
1319         struct kvec *iov;
1320         int len;
1321         int n_iov = 0;
1322         pgoff_t next;
1323         int nr_pages;
1324         __u64 offset = 0;
1325         struct cifsFileInfo *open_file;
1326         struct cifsTconInfo *tcon;
1327         struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1328         struct page *page;
1329         struct pagevec pvec;
1330         int rc = 0;
1331         int scanned = 0;
1332         int xid, long_op;
1333
1334         /*
1335          * BB: Is this meaningful for a non-block-device file system?
1336          * If it is, we should test it again after we do I/O
1337          */
1338         if (wbc->nonblocking && bdi_write_congested(bdi)) {
1339                 wbc->encountered_congestion = 1;
1340                 return 0;
1341         }
1342
1343         cifs_sb = CIFS_SB(mapping->host->i_sb);
1344
1345         /*
1346          * If wsize is smaller that the page cache size, default to writing
1347          * one page at a time via cifs_writepage
1348          */
1349         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1350                 return generic_writepages(mapping, wbc);
1351
1352         iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1353         if (iov == NULL)
1354                 return generic_writepages(mapping, wbc);
1355
1356         /*
1357          * if there's no open file, then this is likely to fail too,
1358          * but it'll at least handle the return. Maybe it should be
1359          * a BUG() instead?
1360          */
1361         open_file = find_writable_file(CIFS_I(mapping->host), false);
1362         if (!open_file) {
1363                 kfree(iov);
1364                 return generic_writepages(mapping, wbc);
1365         }
1366
1367         tcon = tlink_tcon(open_file->tlink);
1368         if (!experimEnabled && tcon->ses->server->secMode &
1369                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1370                 cifsFileInfo_put(open_file);
1371                 return generic_writepages(mapping, wbc);
1372         }
1373         cifsFileInfo_put(open_file);
1374
1375         xid = GetXid();
1376
1377         pagevec_init(&pvec, 0);
1378         if (wbc->range_cyclic) {
1379                 index = mapping->writeback_index; /* Start from prev offset */
1380                 end = -1;
1381         } else {
1382                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1383                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1384                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1385                         range_whole = 1;
1386                 scanned = 1;
1387         }
1388 retry:
1389         while (!done && (index <= end) &&
1390                (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1391                         PAGECACHE_TAG_DIRTY,
1392                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1393                 int first;
1394                 unsigned int i;
1395
1396                 first = -1;
1397                 next = 0;
1398                 n_iov = 0;
1399                 bytes_to_write = 0;
1400
1401                 for (i = 0; i < nr_pages; i++) {
1402                         page = pvec.pages[i];
1403                         /*
1404                          * At this point we hold neither mapping->tree_lock nor
1405                          * lock on the page itself: the page may be truncated or
1406                          * invalidated (changing page->mapping to NULL), or even
1407                          * swizzled back from swapper_space to tmpfs file
1408                          * mapping
1409                          */
1410
1411                         if (first < 0)
1412                                 lock_page(page);
1413                         else if (!trylock_page(page))
1414                                 break;
1415
1416                         if (unlikely(page->mapping != mapping)) {
1417                                 unlock_page(page);
1418                                 break;
1419                         }
1420
1421                         if (!wbc->range_cyclic && page->index > end) {
1422                                 done = 1;
1423                                 unlock_page(page);
1424                                 break;
1425                         }
1426
1427                         if (next && (page->index != next)) {
1428                                 /* Not next consecutive page */
1429                                 unlock_page(page);
1430                                 break;
1431                         }
1432
1433                         if (wbc->sync_mode != WB_SYNC_NONE)
1434                                 wait_on_page_writeback(page);
1435
1436                         if (PageWriteback(page) ||
1437                                         !clear_page_dirty_for_io(page)) {
1438                                 unlock_page(page);
1439                                 break;
1440                         }
1441
1442                         /*
1443                          * This actually clears the dirty bit in the radix tree.
1444                          * See cifs_writepage() for more commentary.
1445                          */
1446                         set_page_writeback(page);
1447
1448                         if (page_offset(page) >= mapping->host->i_size) {
1449                                 done = 1;
1450                                 unlock_page(page);
1451                                 end_page_writeback(page);
1452                                 break;
1453                         }
1454
1455                         /*
1456                          * BB can we get rid of this?  pages are held by pvec
1457                          */
1458                         page_cache_get(page);
1459
1460                         len = min(mapping->host->i_size - page_offset(page),
1461                                   (loff_t)PAGE_CACHE_SIZE);
1462
1463                         /* reserve iov[0] for the smb header */
1464                         n_iov++;
1465                         iov[n_iov].iov_base = kmap(page);
1466                         iov[n_iov].iov_len = len;
1467                         bytes_to_write += len;
1468
1469                         if (first < 0) {
1470                                 first = i;
1471                                 offset = page_offset(page);
1472                         }
1473                         next = page->index + 1;
1474                         if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1475                                 break;
1476                 }
1477                 if (n_iov) {
1478                         open_file = find_writable_file(CIFS_I(mapping->host),
1479                                                         false);
1480                         if (!open_file) {
1481                                 cERROR(1, "No writable handles for inode");
1482                                 rc = -EBADF;
1483                         } else {
1484                                 long_op = cifs_write_timeout(cifsi, offset);
1485                                 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
1486                                                    bytes_to_write, offset,
1487                                                    &bytes_written, iov, n_iov,
1488                                                    long_op);
1489                                 cifsFileInfo_put(open_file);
1490                                 cifs_update_eof(cifsi, offset, bytes_written);
1491                         }
1492
1493                         if (rc || bytes_written < bytes_to_write) {
1494                                 cERROR(1, "Write2 ret %d, wrote %d",
1495                                           rc, bytes_written);
1496                                 /* BB what if continued retry is
1497                                    requested via mount flags? */
1498                                 if (rc == -ENOSPC)
1499                                         set_bit(AS_ENOSPC, &mapping->flags);
1500                                 else
1501                                         set_bit(AS_EIO, &mapping->flags);
1502                         } else {
1503                                 cifs_stats_bytes_written(tcon, bytes_written);
1504                         }
1505
1506                         for (i = 0; i < n_iov; i++) {
1507                                 page = pvec.pages[first + i];
1508                                 /* Should we also set page error on
1509                                 success rc but too little data written? */
1510                                 /* BB investigate retry logic on temporary
1511                                 server crash cases and how recovery works
1512                                 when page marked as error */
1513                                 if (rc)
1514                                         SetPageError(page);
1515                                 kunmap(page);
1516                                 unlock_page(page);
1517                                 end_page_writeback(page);
1518                                 page_cache_release(page);
1519                         }
1520                         if ((wbc->nr_to_write -= n_iov) <= 0)
1521                                 done = 1;
1522                         index = next;
1523                 } else
1524                         /* Need to re-find the pages we skipped */
1525                         index = pvec.pages[0]->index + 1;
1526
1527                 pagevec_release(&pvec);
1528         }
1529         if (!scanned && !done) {
1530                 /*
1531                  * We hit the last page and there is more work to be done: wrap
1532                  * back to the start of the file
1533                  */
1534                 scanned = 1;
1535                 index = 0;
1536                 goto retry;
1537         }
1538         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1539                 mapping->writeback_index = index;
1540
1541         FreeXid(xid);
1542         kfree(iov);
1543         return rc;
1544 }
1545
1546 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1547 {
1548         int rc = -EFAULT;
1549         int xid;
1550
1551         xid = GetXid();
1552 /* BB add check for wbc flags */
1553         page_cache_get(page);
1554         if (!PageUptodate(page))
1555                 cFYI(1, "ppw - page not up to date");
1556
1557         /*
1558          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1559          *
1560          * A writepage() implementation always needs to do either this,
1561          * or re-dirty the page with "redirty_page_for_writepage()" in
1562          * the case of a failure.
1563          *
1564          * Just unlocking the page will cause the radix tree tag-bits
1565          * to fail to update with the state of the page correctly.
1566          */
1567         set_page_writeback(page);
1568         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1569         SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1570         unlock_page(page);
1571         end_page_writeback(page);
1572         page_cache_release(page);
1573         FreeXid(xid);
1574         return rc;
1575 }
1576
1577 static int cifs_write_end(struct file *file, struct address_space *mapping,
1578                         loff_t pos, unsigned len, unsigned copied,
1579                         struct page *page, void *fsdata)
1580 {
1581         int rc;
1582         struct inode *inode = mapping->host;
1583
1584         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1585                  page, pos, copied);
1586
1587         if (PageChecked(page)) {
1588                 if (copied == len)
1589                         SetPageUptodate(page);
1590                 ClearPageChecked(page);
1591         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1592                 SetPageUptodate(page);
1593
1594         if (!PageUptodate(page)) {
1595                 char *page_data;
1596                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1597                 int xid;
1598
1599                 xid = GetXid();
1600                 /* this is probably better than directly calling
1601                    partialpage_write since in this function the file handle is
1602                    known which we might as well leverage */
1603                 /* BB check if anything else missing out of ppw
1604                    such as updating last write time */
1605                 page_data = kmap(page);
1606                 rc = cifs_write(file->private_data, page_data + offset,
1607                                 copied, &pos);
1608                 /* if (rc < 0) should we set writebehind rc? */
1609                 kunmap(page);
1610
1611                 FreeXid(xid);
1612         } else {
1613                 rc = copied;
1614                 pos += copied;
1615                 set_page_dirty(page);
1616         }
1617
1618         if (rc > 0) {
1619                 spin_lock(&inode->i_lock);
1620                 if (pos > inode->i_size)
1621                         i_size_write(inode, pos);
1622                 spin_unlock(&inode->i_lock);
1623         }
1624
1625         unlock_page(page);
1626         page_cache_release(page);
1627
1628         return rc;
1629 }
1630
1631 int cifs_fsync(struct file *file, int datasync)
1632 {
1633         int xid;
1634         int rc = 0;
1635         struct cifsTconInfo *tcon;
1636         struct cifsFileInfo *smbfile = file->private_data;
1637         struct inode *inode = file->f_path.dentry->d_inode;
1638
1639         xid = GetXid();
1640
1641         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1642                 file->f_path.dentry->d_name.name, datasync);
1643
1644         rc = filemap_write_and_wait(inode->i_mapping);
1645         if (rc == 0) {
1646                 rc = CIFS_I(inode)->write_behind_rc;
1647                 CIFS_I(inode)->write_behind_rc = 0;
1648                 tcon = tlink_tcon(smbfile->tlink);
1649                 if (!rc && tcon && smbfile &&
1650                    !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1651                         rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1652         }
1653
1654         FreeXid(xid);
1655         return rc;
1656 }
1657
1658 /* static void cifs_sync_page(struct page *page)
1659 {
1660         struct address_space *mapping;
1661         struct inode *inode;
1662         unsigned long index = page->index;
1663         unsigned int rpages = 0;
1664         int rc = 0;
1665
1666         cFYI(1, "sync page %p", page);
1667         mapping = page->mapping;
1668         if (!mapping)
1669                 return 0;
1670         inode = mapping->host;
1671         if (!inode)
1672                 return; */
1673
1674 /*      fill in rpages then
1675         result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1676
1677 /*      cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1678
1679 #if 0
1680         if (rc < 0)
1681                 return rc;
1682         return 0;
1683 #endif
1684 } */
1685
1686 /*
1687  * As file closes, flush all cached write data for this inode checking
1688  * for write behind errors.
1689  */
1690 int cifs_flush(struct file *file, fl_owner_t id)
1691 {
1692         struct inode *inode = file->f_path.dentry->d_inode;
1693         int rc = 0;
1694
1695         /* Rather than do the steps manually:
1696            lock the inode for writing
1697            loop through pages looking for write behind data (dirty pages)
1698            coalesce into contiguous 16K (or smaller) chunks to write to server
1699            send to server (prefer in parallel)
1700            deal with writebehind errors
1701            unlock inode for writing
1702            filemapfdatawrite appears easier for the time being */
1703
1704         rc = filemap_fdatawrite(inode->i_mapping);
1705         /* reset wb rc if we were able to write out dirty pages */
1706         if (!rc) {
1707                 rc = CIFS_I(inode)->write_behind_rc;
1708                 CIFS_I(inode)->write_behind_rc = 0;
1709         }
1710
1711         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1712
1713         return rc;
1714 }
1715
1716 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1717         size_t read_size, loff_t *poffset)
1718 {
1719         int rc = -EACCES;
1720         unsigned int bytes_read = 0;
1721         unsigned int total_read = 0;
1722         unsigned int current_read_size;
1723         struct cifs_sb_info *cifs_sb;
1724         struct cifsTconInfo *pTcon;
1725         int xid;
1726         struct cifsFileInfo *open_file;
1727         char *smb_read_data;
1728         char __user *current_offset;
1729         struct smb_com_read_rsp *pSMBr;
1730
1731         xid = GetXid();
1732         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1733
1734         if (file->private_data == NULL) {
1735                 rc = -EBADF;
1736                 FreeXid(xid);
1737                 return rc;
1738         }
1739         open_file = file->private_data;
1740         pTcon = tlink_tcon(open_file->tlink);
1741
1742         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1743                 cFYI(1, "attempting read on write only file instance");
1744
1745         for (total_read = 0, current_offset = read_data;
1746              read_size > total_read;
1747              total_read += bytes_read, current_offset += bytes_read) {
1748                 current_read_size = min_t(const int, read_size - total_read,
1749                                           cifs_sb->rsize);
1750                 rc = -EAGAIN;
1751                 smb_read_data = NULL;
1752                 while (rc == -EAGAIN) {
1753                         int buf_type = CIFS_NO_BUFFER;
1754                         if ((open_file->invalidHandle) &&
1755                             (!open_file->closePend)) {
1756                                 rc = cifs_reopen_file(open_file, true);
1757                                 if (rc != 0)
1758                                         break;
1759                         }
1760                         rc = CIFSSMBRead(xid, pTcon,
1761                                          open_file->netfid,
1762                                          current_read_size, *poffset,
1763                                          &bytes_read, &smb_read_data,
1764                                          &buf_type);
1765                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1766                         if (smb_read_data) {
1767                                 if (copy_to_user(current_offset,
1768                                                 smb_read_data +
1769                                                 4 /* RFC1001 length field */ +
1770                                                 le16_to_cpu(pSMBr->DataOffset),
1771                                                 bytes_read))
1772                                         rc = -EFAULT;
1773
1774                                 if (buf_type == CIFS_SMALL_BUFFER)
1775                                         cifs_small_buf_release(smb_read_data);
1776                                 else if (buf_type == CIFS_LARGE_BUFFER)
1777                                         cifs_buf_release(smb_read_data);
1778                                 smb_read_data = NULL;
1779                         }
1780                 }
1781                 if (rc || (bytes_read == 0)) {
1782                         if (total_read) {
1783                                 break;
1784                         } else {
1785                                 FreeXid(xid);
1786                                 return rc;
1787                         }
1788                 } else {
1789                         cifs_stats_bytes_read(pTcon, bytes_read);
1790                         *poffset += bytes_read;
1791                 }
1792         }
1793         FreeXid(xid);
1794         return total_read;
1795 }
1796
1797
1798 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1799         loff_t *poffset)
1800 {
1801         int rc = -EACCES;
1802         unsigned int bytes_read = 0;
1803         unsigned int total_read;
1804         unsigned int current_read_size;
1805         struct cifs_sb_info *cifs_sb;
1806         struct cifsTconInfo *pTcon;
1807         int xid;
1808         char *current_offset;
1809         struct cifsFileInfo *open_file;
1810         int buf_type = CIFS_NO_BUFFER;
1811
1812         xid = GetXid();
1813         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1814
1815         if (file->private_data == NULL) {
1816                 rc = -EBADF;
1817                 FreeXid(xid);
1818                 return rc;
1819         }
1820         open_file = file->private_data;
1821         pTcon = tlink_tcon(open_file->tlink);
1822
1823         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1824                 cFYI(1, "attempting read on write only file instance");
1825
1826         for (total_read = 0, current_offset = read_data;
1827              read_size > total_read;
1828              total_read += bytes_read, current_offset += bytes_read) {
1829                 current_read_size = min_t(const int, read_size - total_read,
1830                                           cifs_sb->rsize);
1831                 /* For windows me and 9x we do not want to request more
1832                 than it negotiated since it will refuse the read then */
1833                 if ((pTcon->ses) &&
1834                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1835                         current_read_size = min_t(const int, current_read_size,
1836                                         pTcon->ses->server->maxBuf - 128);
1837                 }
1838                 rc = -EAGAIN;
1839                 while (rc == -EAGAIN) {
1840                         if ((open_file->invalidHandle) &&
1841                             (!open_file->closePend)) {
1842                                 rc = cifs_reopen_file(open_file, true);
1843                                 if (rc != 0)
1844                                         break;
1845                         }
1846                         rc = CIFSSMBRead(xid, pTcon,
1847                                          open_file->netfid,
1848                                          current_read_size, *poffset,
1849                                          &bytes_read, &current_offset,
1850                                          &buf_type);
1851                 }
1852                 if (rc || (bytes_read == 0)) {
1853                         if (total_read) {
1854                                 break;
1855                         } else {
1856                                 FreeXid(xid);
1857                                 return rc;
1858                         }
1859                 } else {
1860                         cifs_stats_bytes_read(pTcon, total_read);
1861                         *poffset += bytes_read;
1862                 }
1863         }
1864         FreeXid(xid);
1865         return total_read;
1866 }
1867
1868 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1869 {
1870         int rc, xid;
1871
1872         xid = GetXid();
1873         rc = cifs_revalidate_file(file);
1874         if (rc) {
1875                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1876                 FreeXid(xid);
1877                 return rc;
1878         }
1879         rc = generic_file_mmap(file, vma);
1880         FreeXid(xid);
1881         return rc;
1882 }
1883
1884
1885 static void cifs_copy_cache_pages(struct address_space *mapping,
1886         struct list_head *pages, int bytes_read, char *data)
1887 {
1888         struct page *page;
1889         char *target;
1890
1891         while (bytes_read > 0) {
1892                 if (list_empty(pages))
1893                         break;
1894
1895                 page = list_entry(pages->prev, struct page, lru);
1896                 list_del(&page->lru);
1897
1898                 if (add_to_page_cache_lru(page, mapping, page->index,
1899                                       GFP_KERNEL)) {
1900                         page_cache_release(page);
1901                         cFYI(1, "Add page cache failed");
1902                         data += PAGE_CACHE_SIZE;
1903                         bytes_read -= PAGE_CACHE_SIZE;
1904                         continue;
1905                 }
1906                 page_cache_release(page);
1907
1908                 target = kmap_atomic(page, KM_USER0);
1909
1910                 if (PAGE_CACHE_SIZE > bytes_read) {
1911                         memcpy(target, data, bytes_read);
1912                         /* zero the tail end of this partial page */
1913                         memset(target + bytes_read, 0,
1914                                PAGE_CACHE_SIZE - bytes_read);
1915                         bytes_read = 0;
1916                 } else {
1917                         memcpy(target, data, PAGE_CACHE_SIZE);
1918                         bytes_read -= PAGE_CACHE_SIZE;
1919                 }
1920                 kunmap_atomic(target, KM_USER0);
1921
1922                 flush_dcache_page(page);
1923                 SetPageUptodate(page);
1924                 unlock_page(page);
1925                 data += PAGE_CACHE_SIZE;
1926
1927                 /* add page to FS-Cache */
1928                 cifs_readpage_to_fscache(mapping->host, page);
1929         }
1930         return;
1931 }
1932
1933 static int cifs_readpages(struct file *file, struct address_space *mapping,
1934         struct list_head *page_list, unsigned num_pages)
1935 {
1936         int rc = -EACCES;
1937         int xid;
1938         loff_t offset;
1939         struct page *page;
1940         struct cifs_sb_info *cifs_sb;
1941         struct cifsTconInfo *pTcon;
1942         unsigned int bytes_read = 0;
1943         unsigned int read_size, i;
1944         char *smb_read_data = NULL;
1945         struct smb_com_read_rsp *pSMBr;
1946         struct cifsFileInfo *open_file;
1947         int buf_type = CIFS_NO_BUFFER;
1948
1949         xid = GetXid();
1950         if (file->private_data == NULL) {
1951                 rc = -EBADF;
1952                 FreeXid(xid);
1953                 return rc;
1954         }
1955         open_file = file->private_data;
1956         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1957         pTcon = tlink_tcon(open_file->tlink);
1958
1959         /*
1960          * Reads as many pages as possible from fscache. Returns -ENOBUFS
1961          * immediately if the cookie is negative
1962          */
1963         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1964                                          &num_pages);
1965         if (rc == 0)
1966                 goto read_complete;
1967
1968         cFYI(DBG2, "rpages: num pages %d", num_pages);
1969         for (i = 0; i < num_pages; ) {
1970                 unsigned contig_pages;
1971                 struct page *tmp_page;
1972                 unsigned long expected_index;
1973
1974                 if (list_empty(page_list))
1975                         break;
1976
1977                 page = list_entry(page_list->prev, struct page, lru);
1978                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1979
1980                 /* count adjacent pages that we will read into */
1981                 contig_pages = 0;
1982                 expected_index =
1983                         list_entry(page_list->prev, struct page, lru)->index;
1984                 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1985                         if (tmp_page->index == expected_index) {
1986                                 contig_pages++;
1987                                 expected_index++;
1988                         } else
1989                                 break;
1990                 }
1991                 if (contig_pages + i >  num_pages)
1992                         contig_pages = num_pages - i;
1993
1994                 /* for reads over a certain size could initiate async
1995                    read ahead */
1996
1997                 read_size = contig_pages * PAGE_CACHE_SIZE;
1998                 /* Read size needs to be in multiples of one page */
1999                 read_size = min_t(const unsigned int, read_size,
2000                                   cifs_sb->rsize & PAGE_CACHE_MASK);
2001                 cFYI(DBG2, "rpages: read size 0x%x  contiguous pages %d",
2002                                 read_size, contig_pages);
2003                 rc = -EAGAIN;
2004                 while (rc == -EAGAIN) {
2005                         if ((open_file->invalidHandle) &&
2006                             (!open_file->closePend)) {
2007                                 rc = cifs_reopen_file(open_file, true);
2008                                 if (rc != 0)
2009                                         break;
2010                         }
2011
2012                         rc = CIFSSMBRead(xid, pTcon,
2013                                          open_file->netfid,
2014                                          read_size, offset,
2015                                          &bytes_read, &smb_read_data,
2016                                          &buf_type);
2017                         /* BB more RC checks ? */
2018                         if (rc == -EAGAIN) {
2019                                 if (smb_read_data) {
2020                                         if (buf_type == CIFS_SMALL_BUFFER)
2021                                                 cifs_small_buf_release(smb_read_data);
2022                                         else if (buf_type == CIFS_LARGE_BUFFER)
2023                                                 cifs_buf_release(smb_read_data);
2024                                         smb_read_data = NULL;
2025                                 }
2026                         }
2027                 }
2028                 if ((rc < 0) || (smb_read_data == NULL)) {
2029                         cFYI(1, "Read error in readpages: %d", rc);
2030                         break;
2031                 } else if (bytes_read > 0) {
2032                         task_io_account_read(bytes_read);
2033                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2034                         cifs_copy_cache_pages(mapping, page_list, bytes_read,
2035                                 smb_read_data + 4 /* RFC1001 hdr */ +
2036                                 le16_to_cpu(pSMBr->DataOffset));
2037
2038                         i +=  bytes_read >> PAGE_CACHE_SHIFT;
2039                         cifs_stats_bytes_read(pTcon, bytes_read);
2040                         if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2041                                 i++; /* account for partial page */
2042
2043                                 /* server copy of file can have smaller size
2044                                    than client */
2045                                 /* BB do we need to verify this common case ?
2046                                    this case is ok - if we are at server EOF
2047                                    we will hit it on next read */
2048
2049                                 /* break; */
2050                         }
2051                 } else {
2052                         cFYI(1, "No bytes read (%d) at offset %lld . "
2053                                 "Cleaning remaining pages from readahead list",
2054                                 bytes_read, offset);
2055                         /* BB turn off caching and do new lookup on
2056                            file size at server? */
2057                         break;
2058                 }
2059                 if (smb_read_data) {
2060                         if (buf_type == CIFS_SMALL_BUFFER)
2061                                 cifs_small_buf_release(smb_read_data);
2062                         else if (buf_type == CIFS_LARGE_BUFFER)
2063                                 cifs_buf_release(smb_read_data);
2064                         smb_read_data = NULL;
2065                 }
2066                 bytes_read = 0;
2067         }
2068
2069 /* need to free smb_read_data buf before exit */
2070         if (smb_read_data) {
2071                 if (buf_type == CIFS_SMALL_BUFFER)
2072                         cifs_small_buf_release(smb_read_data);
2073                 else if (buf_type == CIFS_LARGE_BUFFER)
2074                         cifs_buf_release(smb_read_data);
2075                 smb_read_data = NULL;
2076         }
2077
2078 read_complete:
2079         FreeXid(xid);
2080         return rc;
2081 }
2082
2083 static int cifs_readpage_worker(struct file *file, struct page *page,
2084         loff_t *poffset)
2085 {
2086         char *read_data;
2087         int rc;
2088
2089         /* Is the page cached? */
2090         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2091         if (rc == 0)
2092                 goto read_complete;
2093
2094         page_cache_get(page);
2095         read_data = kmap(page);
2096         /* for reads over a certain size could initiate async read ahead */
2097
2098         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2099
2100         if (rc < 0)
2101                 goto io_error;
2102         else
2103                 cFYI(1, "Bytes read %d", rc);
2104
2105         file->f_path.dentry->d_inode->i_atime =
2106                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2107
2108         if (PAGE_CACHE_SIZE > rc)
2109                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2110
2111         flush_dcache_page(page);
2112         SetPageUptodate(page);
2113
2114         /* send this page to the cache */
2115         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2116
2117         rc = 0;
2118
2119 io_error:
2120         kunmap(page);
2121         page_cache_release(page);
2122
2123 read_complete:
2124         return rc;
2125 }
2126
2127 static int cifs_readpage(struct file *file, struct page *page)
2128 {
2129         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2130         int rc = -EACCES;
2131         int xid;
2132
2133         xid = GetXid();
2134
2135         if (file->private_data == NULL) {
2136                 rc = -EBADF;
2137                 FreeXid(xid);
2138                 return rc;
2139         }
2140
2141         cFYI(1, "readpage %p at offset %d 0x%x\n",
2142                  page, (int)offset, (int)offset);
2143
2144         rc = cifs_readpage_worker(file, page, &offset);
2145
2146         unlock_page(page);
2147
2148         FreeXid(xid);
2149         return rc;
2150 }
2151
2152 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2153 {
2154         struct cifsFileInfo *open_file;
2155
2156         read_lock(&GlobalSMBSeslock);
2157         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2158                 if (open_file->closePend)
2159                         continue;
2160                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2161                         read_unlock(&GlobalSMBSeslock);
2162                         return 1;
2163                 }
2164         }
2165         read_unlock(&GlobalSMBSeslock);
2166         return 0;
2167 }
2168
2169 /* We do not want to update the file size from server for inodes
2170    open for write - to avoid races with writepage extending
2171    the file - in the future we could consider allowing
2172    refreshing the inode only on increases in the file size
2173    but this is tricky to do without racing with writebehind
2174    page caching in the current Linux kernel design */
2175 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2176 {
2177         if (!cifsInode)
2178                 return true;
2179
2180         if (is_inode_writable(cifsInode)) {
2181                 /* This inode is open for write at least once */
2182                 struct cifs_sb_info *cifs_sb;
2183
2184                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2185                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2186                         /* since no page cache to corrupt on directio
2187                         we can change size safely */
2188                         return true;
2189                 }
2190
2191                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2192                         return true;
2193
2194                 return false;
2195         } else
2196                 return true;
2197 }
2198
2199 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2200                         loff_t pos, unsigned len, unsigned flags,
2201                         struct page **pagep, void **fsdata)
2202 {
2203         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2204         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2205         loff_t page_start = pos & PAGE_MASK;
2206         loff_t i_size;
2207         struct page *page;
2208         int rc = 0;
2209
2210         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2211
2212         page = grab_cache_page_write_begin(mapping, index, flags);
2213         if (!page) {
2214                 rc = -ENOMEM;
2215                 goto out;
2216         }
2217
2218         if (PageUptodate(page))
2219                 goto out;
2220
2221         /*
2222          * If we write a full page it will be up to date, no need to read from
2223          * the server. If the write is short, we'll end up doing a sync write
2224          * instead.
2225          */
2226         if (len == PAGE_CACHE_SIZE)
2227                 goto out;
2228
2229         /*
2230          * optimize away the read when we have an oplock, and we're not
2231          * expecting to use any of the data we'd be reading in. That
2232          * is, when the page lies beyond the EOF, or straddles the EOF
2233          * and the write will cover all of the existing data.
2234          */
2235         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2236                 i_size = i_size_read(mapping->host);
2237                 if (page_start >= i_size ||
2238                     (offset == 0 && (pos + len) >= i_size)) {
2239                         zero_user_segments(page, 0, offset,
2240                                            offset + len,
2241                                            PAGE_CACHE_SIZE);
2242                         /*
2243                          * PageChecked means that the parts of the page
2244                          * to which we're not writing are considered up
2245                          * to date. Once the data is copied to the
2246                          * page, it can be set uptodate.
2247                          */
2248                         SetPageChecked(page);
2249                         goto out;
2250                 }
2251         }
2252
2253         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2254                 /*
2255                  * might as well read a page, it is fast enough. If we get
2256                  * an error, we don't need to return it. cifs_write_end will
2257                  * do a sync write instead since PG_uptodate isn't set.
2258                  */
2259                 cifs_readpage_worker(file, page, &page_start);
2260         } else {
2261                 /* we could try using another file handle if there is one -
2262                    but how would we lock it to prevent close of that handle
2263                    racing with this read? In any case
2264                    this will be written out by write_end so is fine */
2265         }
2266 out:
2267         *pagep = page;
2268         return rc;
2269 }
2270
2271 static int cifs_release_page(struct page *page, gfp_t gfp)
2272 {
2273         if (PagePrivate(page))
2274                 return 0;
2275
2276         return cifs_fscache_release_page(page, gfp);
2277 }
2278
2279 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2280 {
2281         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2282
2283         if (offset == 0)
2284                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2285 }
2286
2287 void cifs_oplock_break(struct work_struct *work)
2288 {
2289         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2290                                                   oplock_break);
2291         struct inode *inode = cfile->dentry->d_inode;
2292         struct cifsInodeInfo *cinode = CIFS_I(inode);
2293         int rc, waitrc = 0;
2294
2295         if (inode && S_ISREG(inode->i_mode)) {
2296                 if (cinode->clientCanCacheRead)
2297                         break_lease(inode, O_RDONLY);
2298                 else
2299                         break_lease(inode, O_WRONLY);
2300                 rc = filemap_fdatawrite(inode->i_mapping);
2301                 if (cinode->clientCanCacheRead == 0) {
2302                         waitrc = filemap_fdatawait(inode->i_mapping);
2303                         invalidate_remote_inode(inode);
2304                 }
2305                 if (!rc)
2306                         rc = waitrc;
2307                 if (rc)
2308                         cinode->write_behind_rc = rc;
2309                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2310         }
2311
2312         /*
2313          * releasing stale oplock after recent reconnect of smb session using
2314          * a now incorrect file handle is not a data integrity issue but do
2315          * not bother sending an oplock release if session to server still is
2316          * disconnected since oplock already released by the server
2317          */
2318         if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2319                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2320                                  0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
2321                 cFYI(1, "Oplock release rc = %d", rc);
2322         }
2323
2324         /*
2325          * We might have kicked in before is_valid_oplock_break()
2326          * finished grabbing reference for us.  Make sure it's done by
2327          * waiting for GlobalSMSSeslock.
2328          */
2329         write_lock(&GlobalSMBSeslock);
2330         write_unlock(&GlobalSMBSeslock);
2331
2332         cifs_oplock_break_put(cfile);
2333 }
2334
2335 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2336 {
2337         cifs_sb_active(cfile->dentry->d_sb);
2338         cifsFileInfo_get(cfile);
2339 }
2340
2341 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2342 {
2343         cifsFileInfo_put(cfile);
2344         cifs_sb_deactive(cfile->dentry->d_sb);
2345 }
2346
2347 const struct address_space_operations cifs_addr_ops = {
2348         .readpage = cifs_readpage,
2349         .readpages = cifs_readpages,
2350         .writepage = cifs_writepage,
2351         .writepages = cifs_writepages,
2352         .write_begin = cifs_write_begin,
2353         .write_end = cifs_write_end,
2354         .set_page_dirty = __set_page_dirty_nobuffers,
2355         .releasepage = cifs_release_page,
2356         .invalidatepage = cifs_invalidate_page,
2357         /* .sync_page = cifs_sync_page, */
2358         /* .direct_IO = */
2359 };
2360
2361 /*
2362  * cifs_readpages requires the server to support a buffer large enough to
2363  * contain the header plus one complete page of data.  Otherwise, we need
2364  * to leave cifs_readpages out of the address space operations.
2365  */
2366 const struct address_space_operations cifs_addr_ops_smallbuf = {
2367         .readpage = cifs_readpage,
2368         .writepage = cifs_writepage,
2369         .writepages = cifs_writepages,
2370         .write_begin = cifs_write_begin,
2371         .write_end = cifs_write_end,
2372         .set_page_dirty = __set_page_dirty_nobuffers,
2373         .releasepage = cifs_release_page,
2374         .invalidatepage = cifs_invalidate_page,
2375         /* .sync_page = cifs_sync_page, */
2376         /* .direct_IO = */
2377 };