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