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