fs/cifs/file.c

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