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